blob: ba09ece925b797b88b9fc8f02e3d3f183e8162c6 [file] [log] [blame]
Jeff Brown5912f952013-07-01 19:10:31 -07001/*
2 * Copyright (C) 2011 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
Siarhei Vishniakou16a2e302019-01-14 19:21:45 -080017#include <array>
Jeff Brown5912f952013-07-01 19:10:31 -070018#include <math.h>
19
Prabir Pradhan7e1443f2021-07-23 21:01:55 +000020#include <android-base/properties.h>
chaviw09c8d2d2020-08-24 15:48:26 -070021#include <attestation/HmacKeyManager.h>
Jeff Brown5912f952013-07-01 19:10:31 -070022#include <binder/Parcel.h>
Jeff Brown5912f952013-07-01 19:10:31 -070023#include <gtest/gtest.h>
chaviw3277faf2021-05-19 16:45:23 -050024#include <gui/constants.h>
Jeff Brown5912f952013-07-01 19:10:31 -070025#include <input/Input.h>
26
27namespace android {
28
Siarhei Vishniakou777a10b2018-01-31 16:45:06 -080029// Default display id.
30static constexpr int32_t DISPLAY_ID = ADISPLAY_ID_DEFAULT;
31
Prabir Pradhan00e029d2023-03-09 20:11:09 +000032static constexpr float EPSILON = MotionEvent::ROUNDING_PRECISION;
33
Siarhei Vishniakou9c858ac2020-01-23 14:20:11 -060034class BaseTest : public testing::Test {
35protected:
36 static constexpr std::array<uint8_t, 32> HMAC = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
37 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
38 22, 23, 24, 25, 26, 27, 28, 29, 30, 31};
39};
Jeff Brown5912f952013-07-01 19:10:31 -070040
41// --- PointerCoordsTest ---
42
43class PointerCoordsTest : public BaseTest {
44};
45
46TEST_F(PointerCoordsTest, ClearSetsBitsToZero) {
47 PointerCoords coords;
48 coords.clear();
49
50 ASSERT_EQ(0ULL, coords.bits);
Philip Quinnafb31282022-12-20 18:17:55 -080051 ASSERT_FALSE(coords.isResampled);
Jeff Brown5912f952013-07-01 19:10:31 -070052}
53
54TEST_F(PointerCoordsTest, AxisValues) {
Jeff Brown5912f952013-07-01 19:10:31 -070055 PointerCoords coords;
56 coords.clear();
57
58 // Check invariants when no axes are present.
59 ASSERT_EQ(0, coords.getAxisValue(0))
60 << "getAxisValue should return zero because axis is not present";
61 ASSERT_EQ(0, coords.getAxisValue(1))
62 << "getAxisValue should return zero because axis is not present";
63
64 // Set first axis.
65 ASSERT_EQ(OK, coords.setAxisValue(1, 5));
Jeff Brown5912f952013-07-01 19:10:31 -070066 ASSERT_EQ(5, coords.values[0]);
Narayan Kamathb8290c22014-05-06 11:31:37 +010067 ASSERT_EQ(0x4000000000000000ULL, coords.bits);
Jeff Brown5912f952013-07-01 19:10:31 -070068
69 ASSERT_EQ(0, coords.getAxisValue(0))
70 << "getAxisValue should return zero because axis is not present";
71 ASSERT_EQ(5, coords.getAxisValue(1))
72 << "getAxisValue should return value of axis";
73
74 // Set an axis with a higher id than all others. (appending value at the end)
75 ASSERT_EQ(OK, coords.setAxisValue(3, 2));
Narayan Kamathb8290c22014-05-06 11:31:37 +010076 ASSERT_EQ(0x5000000000000000ULL, coords.bits);
Jeff Brown5912f952013-07-01 19:10:31 -070077 ASSERT_EQ(5, coords.values[0]);
78 ASSERT_EQ(2, coords.values[1]);
79
80 ASSERT_EQ(0, coords.getAxisValue(0))
81 << "getAxisValue should return zero because axis is not present";
82 ASSERT_EQ(5, coords.getAxisValue(1))
83 << "getAxisValue should return value of axis";
84 ASSERT_EQ(0, coords.getAxisValue(2))
85 << "getAxisValue should return zero because axis is not present";
86 ASSERT_EQ(2, coords.getAxisValue(3))
87 << "getAxisValue should return value of axis";
88
89 // Set an axis with an id lower than all others. (prepending value at beginning)
90 ASSERT_EQ(OK, coords.setAxisValue(0, 4));
Narayan Kamathb8290c22014-05-06 11:31:37 +010091 ASSERT_EQ(0xd000000000000000ULL, coords.bits);
Jeff Brown5912f952013-07-01 19:10:31 -070092 ASSERT_EQ(4, coords.values[0]);
93 ASSERT_EQ(5, coords.values[1]);
94 ASSERT_EQ(2, coords.values[2]);
95
96 ASSERT_EQ(4, coords.getAxisValue(0))
97 << "getAxisValue should return value of axis";
98 ASSERT_EQ(5, coords.getAxisValue(1))
99 << "getAxisValue should return value of axis";
100 ASSERT_EQ(0, coords.getAxisValue(2))
101 << "getAxisValue should return zero because axis is not present";
102 ASSERT_EQ(2, coords.getAxisValue(3))
103 << "getAxisValue should return value of axis";
104
105 // Set an axis with an id between the others. (inserting value in the middle)
106 ASSERT_EQ(OK, coords.setAxisValue(2, 1));
Narayan Kamathb8290c22014-05-06 11:31:37 +0100107 ASSERT_EQ(0xf000000000000000ULL, coords.bits);
Jeff Brown5912f952013-07-01 19:10:31 -0700108 ASSERT_EQ(4, coords.values[0]);
109 ASSERT_EQ(5, coords.values[1]);
110 ASSERT_EQ(1, coords.values[2]);
111 ASSERT_EQ(2, coords.values[3]);
112
113 ASSERT_EQ(4, coords.getAxisValue(0))
114 << "getAxisValue should return value of axis";
115 ASSERT_EQ(5, coords.getAxisValue(1))
116 << "getAxisValue should return value of axis";
117 ASSERT_EQ(1, coords.getAxisValue(2))
118 << "getAxisValue should return value of axis";
119 ASSERT_EQ(2, coords.getAxisValue(3))
120 << "getAxisValue should return value of axis";
121
122 // Set an existing axis value in place.
123 ASSERT_EQ(OK, coords.setAxisValue(1, 6));
Narayan Kamathb8290c22014-05-06 11:31:37 +0100124 ASSERT_EQ(0xf000000000000000ULL, coords.bits);
Jeff Brown5912f952013-07-01 19:10:31 -0700125 ASSERT_EQ(4, coords.values[0]);
126 ASSERT_EQ(6, coords.values[1]);
127 ASSERT_EQ(1, coords.values[2]);
128 ASSERT_EQ(2, coords.values[3]);
129
130 ASSERT_EQ(4, coords.getAxisValue(0))
131 << "getAxisValue should return value of axis";
132 ASSERT_EQ(6, coords.getAxisValue(1))
133 << "getAxisValue should return value of axis";
134 ASSERT_EQ(1, coords.getAxisValue(2))
135 << "getAxisValue should return value of axis";
136 ASSERT_EQ(2, coords.getAxisValue(3))
137 << "getAxisValue should return value of axis";
138
139 // Set maximum number of axes.
140 for (size_t axis = 4; axis < PointerCoords::MAX_AXES; axis++) {
141 ASSERT_EQ(OK, coords.setAxisValue(axis, axis));
142 }
143 ASSERT_EQ(PointerCoords::MAX_AXES, __builtin_popcountll(coords.bits));
144
145 // Try to set one more axis beyond maximum number.
146 // Ensure bits are unchanged.
147 ASSERT_EQ(NO_MEMORY, coords.setAxisValue(PointerCoords::MAX_AXES, 100));
148 ASSERT_EQ(PointerCoords::MAX_AXES, __builtin_popcountll(coords.bits));
149}
150
151TEST_F(PointerCoordsTest, Parcel) {
152 Parcel parcel;
153
154 PointerCoords inCoords;
155 inCoords.clear();
156 PointerCoords outCoords;
157
158 // Round trip with empty coords.
159 inCoords.writeToParcel(&parcel);
160 parcel.setDataPosition(0);
161 outCoords.readFromParcel(&parcel);
162
163 ASSERT_EQ(0ULL, outCoords.bits);
Philip Quinnafb31282022-12-20 18:17:55 -0800164 ASSERT_FALSE(outCoords.isResampled);
Jeff Brown5912f952013-07-01 19:10:31 -0700165
166 // Round trip with some values.
167 parcel.freeData();
168 inCoords.setAxisValue(2, 5);
169 inCoords.setAxisValue(5, 8);
Philip Quinnafb31282022-12-20 18:17:55 -0800170 inCoords.isResampled = true;
Jeff Brown5912f952013-07-01 19:10:31 -0700171
172 inCoords.writeToParcel(&parcel);
173 parcel.setDataPosition(0);
174 outCoords.readFromParcel(&parcel);
175
176 ASSERT_EQ(outCoords.bits, inCoords.bits);
177 ASSERT_EQ(outCoords.values[0], inCoords.values[0]);
178 ASSERT_EQ(outCoords.values[1], inCoords.values[1]);
Philip Quinnafb31282022-12-20 18:17:55 -0800179 ASSERT_TRUE(outCoords.isResampled);
Jeff Brown5912f952013-07-01 19:10:31 -0700180}
181
182
183// --- KeyEventTest ---
184
185class KeyEventTest : public BaseTest {
186};
187
188TEST_F(KeyEventTest, Properties) {
189 KeyEvent event;
190
191 // Initialize and get properties.
Siarhei Vishniakou9c858ac2020-01-23 14:20:11 -0600192 constexpr nsecs_t ARBITRARY_DOWN_TIME = 1;
193 constexpr nsecs_t ARBITRARY_EVENT_TIME = 2;
Garfield Tan4cc839f2020-01-24 11:26:14 -0800194 const int32_t id = InputEvent::nextId();
195 event.initialize(id, 2, AINPUT_SOURCE_GAMEPAD, DISPLAY_ID, HMAC, AKEY_EVENT_ACTION_DOWN,
Siarhei Vishniakou9c858ac2020-01-23 14:20:11 -0600196 AKEY_EVENT_FLAG_FROM_SYSTEM, AKEYCODE_BUTTON_X, 121, AMETA_ALT_ON, 1,
197 ARBITRARY_DOWN_TIME, ARBITRARY_EVENT_TIME);
Jeff Brown5912f952013-07-01 19:10:31 -0700198
Garfield Tan4cc839f2020-01-24 11:26:14 -0800199 ASSERT_EQ(id, event.getId());
Siarhei Vishniakou63b63612023-04-12 11:00:23 -0700200 ASSERT_EQ(InputEventType::KEY, event.getType());
Jeff Brown5912f952013-07-01 19:10:31 -0700201 ASSERT_EQ(2, event.getDeviceId());
Siarhei Vishniakou3826d472020-01-27 10:44:40 -0600202 ASSERT_EQ(AINPUT_SOURCE_GAMEPAD, event.getSource());
Siarhei Vishniakoua62a8dd2018-06-08 21:17:33 +0100203 ASSERT_EQ(DISPLAY_ID, event.getDisplayId());
Siarhei Vishniakou9c858ac2020-01-23 14:20:11 -0600204 EXPECT_EQ(HMAC, event.getHmac());
Jeff Brown5912f952013-07-01 19:10:31 -0700205 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, event.getAction());
206 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, event.getFlags());
207 ASSERT_EQ(AKEYCODE_BUTTON_X, event.getKeyCode());
208 ASSERT_EQ(121, event.getScanCode());
209 ASSERT_EQ(AMETA_ALT_ON, event.getMetaState());
210 ASSERT_EQ(1, event.getRepeatCount());
211 ASSERT_EQ(ARBITRARY_DOWN_TIME, event.getDownTime());
212 ASSERT_EQ(ARBITRARY_EVENT_TIME, event.getEventTime());
213
214 // Set source.
215 event.setSource(AINPUT_SOURCE_JOYSTICK);
Siarhei Vishniakou3826d472020-01-27 10:44:40 -0600216 ASSERT_EQ(AINPUT_SOURCE_JOYSTICK, event.getSource());
Siarhei Vishniakoua62a8dd2018-06-08 21:17:33 +0100217
218 // Set display id.
219 constexpr int32_t newDisplayId = 2;
220 event.setDisplayId(newDisplayId);
221 ASSERT_EQ(newDisplayId, event.getDisplayId());
Jeff Brown5912f952013-07-01 19:10:31 -0700222}
223
224
225// --- MotionEventTest ---
226
227class MotionEventTest : public BaseTest {
228protected:
Siarhei Vishniakou9c858ac2020-01-23 14:20:11 -0600229 static constexpr nsecs_t ARBITRARY_DOWN_TIME = 1;
230 static constexpr nsecs_t ARBITRARY_EVENT_TIME = 2;
231 static constexpr float X_SCALE = 2.0;
232 static constexpr float Y_SCALE = 3.0;
233 static constexpr float X_OFFSET = 1;
234 static constexpr float Y_OFFSET = 1.1;
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700235 static constexpr float RAW_X_SCALE = 4.0;
236 static constexpr float RAW_Y_SCALE = -5.0;
237 static constexpr float RAW_X_OFFSET = 12;
238 static constexpr float RAW_Y_OFFSET = -41.1;
Jeff Brown5912f952013-07-01 19:10:31 -0700239
Prabir Pradhan00e029d2023-03-09 20:11:09 +0000240 void SetUp() override;
241
Garfield Tan4cc839f2020-01-24 11:26:14 -0800242 int32_t mId;
chaviw9eaa22c2020-07-01 16:21:27 -0700243 ui::Transform mTransform;
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700244 ui::Transform mRawTransform;
Prabir Pradhan00e029d2023-03-09 20:11:09 +0000245 PointerProperties mPointerProperties[2];
246 struct Sample {
247 PointerCoords pointerCoords[2];
248 };
249 std::array<Sample, 3> mSamples{};
Garfield Tan4cc839f2020-01-24 11:26:14 -0800250
Jeff Brown5912f952013-07-01 19:10:31 -0700251 void initializeEventWithHistory(MotionEvent* event);
252 void assertEqualsEventWithHistory(const MotionEvent* event);
253};
254
Prabir Pradhan00e029d2023-03-09 20:11:09 +0000255void MotionEventTest::SetUp() {
Garfield Tan4cc839f2020-01-24 11:26:14 -0800256 mId = InputEvent::nextId();
chaviw9eaa22c2020-07-01 16:21:27 -0700257 mTransform.set({X_SCALE, 0, X_OFFSET, 0, Y_SCALE, Y_OFFSET, 0, 0, 1});
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700258 mRawTransform.set({RAW_X_SCALE, 0, RAW_X_OFFSET, 0, RAW_Y_SCALE, RAW_Y_OFFSET, 0, 0, 1});
Garfield Tan4cc839f2020-01-24 11:26:14 -0800259
Prabir Pradhan00e029d2023-03-09 20:11:09 +0000260 mPointerProperties[0].clear();
261 mPointerProperties[0].id = 1;
Siarhei Vishniakou6d73f832022-07-21 17:27:03 -0700262 mPointerProperties[0].toolType = ToolType::FINGER;
Prabir Pradhan00e029d2023-03-09 20:11:09 +0000263 mPointerProperties[1].clear();
264 mPointerProperties[1].id = 2;
Siarhei Vishniakou6d73f832022-07-21 17:27:03 -0700265 mPointerProperties[1].toolType = ToolType::STYLUS;
Jeff Brown5912f952013-07-01 19:10:31 -0700266
Prabir Pradhan00e029d2023-03-09 20:11:09 +0000267 mSamples[0].pointerCoords[0].clear();
268 mSamples[0].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X, 10);
269 mSamples[0].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, 11);
270 mSamples[0].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 12);
271 mSamples[0].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 13);
272 mSamples[0].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 14);
273 mSamples[0].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 15);
274 mSamples[0].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 16);
275 mSamples[0].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 17);
276 mSamples[0].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 18);
277 mSamples[0].pointerCoords[0].isResampled = true;
278 mSamples[0].pointerCoords[1].clear();
279 mSamples[0].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_X, 20);
280 mSamples[0].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_Y, 21);
281 mSamples[0].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 22);
282 mSamples[0].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 23);
283 mSamples[0].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 24);
284 mSamples[0].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 25);
285 mSamples[0].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 26);
286 mSamples[0].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 27);
287 mSamples[0].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 28);
288
289 mSamples[1].pointerCoords[0].clear();
290 mSamples[1].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X, 110);
291 mSamples[1].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, 111);
292 mSamples[1].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 112);
293 mSamples[1].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 113);
294 mSamples[1].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 114);
295 mSamples[1].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 115);
296 mSamples[1].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 116);
297 mSamples[1].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 117);
298 mSamples[1].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 118);
299 mSamples[1].pointerCoords[0].isResampled = true;
300 mSamples[1].pointerCoords[1].clear();
301 mSamples[1].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_X, 120);
302 mSamples[1].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_Y, 121);
303 mSamples[1].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 122);
304 mSamples[1].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 123);
305 mSamples[1].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 124);
306 mSamples[1].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 125);
307 mSamples[1].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 126);
308 mSamples[1].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 127);
309 mSamples[1].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 128);
310 mSamples[1].pointerCoords[1].isResampled = true;
311
312 mSamples[2].pointerCoords[0].clear();
313 mSamples[2].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X, 210);
314 mSamples[2].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, 211);
315 mSamples[2].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 212);
316 mSamples[2].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 213);
317 mSamples[2].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 214);
318 mSamples[2].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 215);
319 mSamples[2].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 216);
320 mSamples[2].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 217);
321 mSamples[2].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 218);
322 mSamples[2].pointerCoords[1].clear();
323 mSamples[2].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_X, 220);
324 mSamples[2].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_Y, 221);
325 mSamples[2].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 222);
326 mSamples[2].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 223);
327 mSamples[2].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 224);
328 mSamples[2].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 225);
329 mSamples[2].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 226);
330 mSamples[2].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 227);
331 mSamples[2].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 228);
332}
333
334void MotionEventTest::initializeEventWithHistory(MotionEvent* event) {
Garfield Tan4cc839f2020-01-24 11:26:14 -0800335 event->initialize(mId, 2, AINPUT_SOURCE_TOUCHSCREEN, DISPLAY_ID, HMAC,
336 AMOTION_EVENT_ACTION_MOVE, 0, AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED,
337 AMOTION_EVENT_EDGE_FLAG_TOP, AMETA_ALT_ON, AMOTION_EVENT_BUTTON_PRIMARY,
chaviw9eaa22c2020-07-01 16:21:27 -0700338 MotionClassification::NONE, mTransform, 2.0f, 2.1f,
Siarhei Vishniakou9c858ac2020-01-23 14:20:11 -0600339 AMOTION_EVENT_INVALID_CURSOR_POSITION, AMOTION_EVENT_INVALID_CURSOR_POSITION,
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700340 mRawTransform, ARBITRARY_DOWN_TIME, ARBITRARY_EVENT_TIME, 2,
Prabir Pradhan00e029d2023-03-09 20:11:09 +0000341 mPointerProperties, mSamples[0].pointerCoords);
342 event->addSample(ARBITRARY_EVENT_TIME + 1, mSamples[1].pointerCoords);
343 event->addSample(ARBITRARY_EVENT_TIME + 2, mSamples[2].pointerCoords);
Jeff Brown5912f952013-07-01 19:10:31 -0700344}
345
346void MotionEventTest::assertEqualsEventWithHistory(const MotionEvent* event) {
347 // Check properties.
Garfield Tan4cc839f2020-01-24 11:26:14 -0800348 ASSERT_EQ(mId, event->getId());
Siarhei Vishniakou63b63612023-04-12 11:00:23 -0700349 ASSERT_EQ(InputEventType::MOTION, event->getType());
Jeff Brown5912f952013-07-01 19:10:31 -0700350 ASSERT_EQ(2, event->getDeviceId());
Siarhei Vishniakou3826d472020-01-27 10:44:40 -0600351 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, event->getSource());
Siarhei Vishniakou777a10b2018-01-31 16:45:06 -0800352 ASSERT_EQ(DISPLAY_ID, event->getDisplayId());
Siarhei Vishniakou9c858ac2020-01-23 14:20:11 -0600353 EXPECT_EQ(HMAC, event->getHmac());
Jeff Brown5912f952013-07-01 19:10:31 -0700354 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, event->getAction());
355 ASSERT_EQ(AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED, event->getFlags());
356 ASSERT_EQ(AMOTION_EVENT_EDGE_FLAG_TOP, event->getEdgeFlags());
357 ASSERT_EQ(AMETA_ALT_ON, event->getMetaState());
358 ASSERT_EQ(AMOTION_EVENT_BUTTON_PRIMARY, event->getButtonState());
Siarhei Vishniakou16a2e302019-01-14 19:21:45 -0800359 ASSERT_EQ(MotionClassification::NONE, event->getClassification());
chaviw9eaa22c2020-07-01 16:21:27 -0700360 EXPECT_EQ(mTransform, event->getTransform());
Prabir Pradhanadd8a4a2024-03-05 22:18:09 +0000361 ASSERT_NEAR((-RAW_X_OFFSET / RAW_X_SCALE) * X_SCALE + X_OFFSET, event->getRawXOffset(),
362 EPSILON);
363 ASSERT_NEAR((-RAW_Y_OFFSET / RAW_Y_SCALE) * Y_SCALE + Y_OFFSET, event->getRawYOffset(),
364 EPSILON);
Jeff Brown5912f952013-07-01 19:10:31 -0700365 ASSERT_EQ(2.0f, event->getXPrecision());
366 ASSERT_EQ(2.1f, event->getYPrecision());
367 ASSERT_EQ(ARBITRARY_DOWN_TIME, event->getDownTime());
368
369 ASSERT_EQ(2U, event->getPointerCount());
370 ASSERT_EQ(1, event->getPointerId(0));
Siarhei Vishniakou6d73f832022-07-21 17:27:03 -0700371 ASSERT_EQ(ToolType::FINGER, event->getToolType(0));
Jeff Brown5912f952013-07-01 19:10:31 -0700372 ASSERT_EQ(2, event->getPointerId(1));
Siarhei Vishniakou6d73f832022-07-21 17:27:03 -0700373 ASSERT_EQ(ToolType::STYLUS, event->getToolType(1));
Jeff Brown5912f952013-07-01 19:10:31 -0700374
375 ASSERT_EQ(2U, event->getHistorySize());
376
377 // Check data.
378 ASSERT_EQ(ARBITRARY_EVENT_TIME, event->getHistoricalEventTime(0));
379 ASSERT_EQ(ARBITRARY_EVENT_TIME + 1, event->getHistoricalEventTime(1));
380 ASSERT_EQ(ARBITRARY_EVENT_TIME + 2, event->getEventTime());
381
Prabir Pradhan00e029d2023-03-09 20:11:09 +0000382 // Ensure the underlying PointerCoords are identical.
383 for (int sampleIdx = 0; sampleIdx < 3; sampleIdx++) {
384 for (int pointerIdx = 0; pointerIdx < 2; pointerIdx++) {
385 ASSERT_EQ(mSamples[sampleIdx].pointerCoords[pointerIdx],
386 event->getSamplePointerCoords()[sampleIdx * 2 + pointerIdx]);
387 }
388 }
Jeff Brown5912f952013-07-01 19:10:31 -0700389
Prabir Pradhan00e029d2023-03-09 20:11:09 +0000390 ASSERT_NEAR(11, event->getHistoricalRawPointerCoords(0, 0)->getAxisValue(AMOTION_EVENT_AXIS_Y),
391 EPSILON);
392 ASSERT_NEAR(21, event->getHistoricalRawPointerCoords(1, 0)->getAxisValue(AMOTION_EVENT_AXIS_Y),
393 EPSILON);
394 ASSERT_NEAR(111, event->getHistoricalRawPointerCoords(0, 1)->getAxisValue(AMOTION_EVENT_AXIS_Y),
395 EPSILON);
396 ASSERT_NEAR(121, event->getHistoricalRawPointerCoords(1, 1)->getAxisValue(AMOTION_EVENT_AXIS_Y),
397 EPSILON);
398 ASSERT_NEAR(211, event->getRawPointerCoords(0)->getAxisValue(AMOTION_EVENT_AXIS_Y), EPSILON);
399 ASSERT_NEAR(221, event->getRawPointerCoords(1)->getAxisValue(AMOTION_EVENT_AXIS_Y), EPSILON);
Jeff Brown5912f952013-07-01 19:10:31 -0700400
Prabir Pradhan00e029d2023-03-09 20:11:09 +0000401 ASSERT_NEAR(RAW_Y_OFFSET + 11 * RAW_Y_SCALE,
402 event->getHistoricalRawAxisValue(AMOTION_EVENT_AXIS_Y, 0, 0), EPSILON);
403 ASSERT_NEAR(RAW_Y_OFFSET + 21 * RAW_Y_SCALE,
404 event->getHistoricalRawAxisValue(AMOTION_EVENT_AXIS_Y, 1, 0), EPSILON);
405 ASSERT_NEAR(RAW_Y_OFFSET + 111 * RAW_Y_SCALE,
406 event->getHistoricalRawAxisValue(AMOTION_EVENT_AXIS_Y, 0, 1), EPSILON);
407 ASSERT_NEAR(RAW_Y_OFFSET + 121 * RAW_Y_SCALE,
408 event->getHistoricalRawAxisValue(AMOTION_EVENT_AXIS_Y, 1, 1), EPSILON);
409 ASSERT_NEAR(RAW_Y_OFFSET + 211 * RAW_Y_SCALE, event->getRawAxisValue(AMOTION_EVENT_AXIS_Y, 0),
410 EPSILON);
411 ASSERT_NEAR(RAW_Y_OFFSET + 221 * RAW_Y_SCALE, event->getRawAxisValue(AMOTION_EVENT_AXIS_Y, 1),
412 EPSILON);
Jeff Brown5912f952013-07-01 19:10:31 -0700413
Prabir Pradhan00e029d2023-03-09 20:11:09 +0000414 ASSERT_NEAR(RAW_X_OFFSET + 10 * RAW_X_SCALE, event->getHistoricalRawX(0, 0), EPSILON);
415 ASSERT_NEAR(RAW_X_OFFSET + 20 * RAW_X_SCALE, event->getHistoricalRawX(1, 0), EPSILON);
416 ASSERT_NEAR(RAW_X_OFFSET + 110 * RAW_X_SCALE, event->getHistoricalRawX(0, 1), EPSILON);
417 ASSERT_NEAR(RAW_X_OFFSET + 120 * RAW_X_SCALE, event->getHistoricalRawX(1, 1), EPSILON);
418 ASSERT_NEAR(RAW_X_OFFSET + 210 * RAW_X_SCALE, event->getRawX(0), EPSILON);
419 ASSERT_NEAR(RAW_X_OFFSET + 220 * RAW_X_SCALE, event->getRawX(1), EPSILON);
Jeff Brown5912f952013-07-01 19:10:31 -0700420
Prabir Pradhan00e029d2023-03-09 20:11:09 +0000421 ASSERT_NEAR(RAW_Y_OFFSET + 11 * RAW_Y_SCALE, event->getHistoricalRawY(0, 0), EPSILON);
422 ASSERT_NEAR(RAW_Y_OFFSET + 21 * RAW_Y_SCALE, event->getHistoricalRawY(1, 0), EPSILON);
423 ASSERT_NEAR(RAW_Y_OFFSET + 111 * RAW_Y_SCALE, event->getHistoricalRawY(0, 1), EPSILON);
424 ASSERT_NEAR(RAW_Y_OFFSET + 121 * RAW_Y_SCALE, event->getHistoricalRawY(1, 1), EPSILON);
425 ASSERT_NEAR(RAW_Y_OFFSET + 211 * RAW_Y_SCALE, event->getRawY(0), EPSILON);
426 ASSERT_NEAR(RAW_Y_OFFSET + 221 * RAW_Y_SCALE, event->getRawY(1), EPSILON);
Jeff Brown5912f952013-07-01 19:10:31 -0700427
Prabir Pradhan00e029d2023-03-09 20:11:09 +0000428 ASSERT_NEAR(X_OFFSET + 10 * X_SCALE, event->getHistoricalX(0, 0), EPSILON);
429 ASSERT_NEAR(X_OFFSET + 20 * X_SCALE, event->getHistoricalX(1, 0), EPSILON);
430 ASSERT_NEAR(X_OFFSET + 110 * X_SCALE, event->getHistoricalX(0, 1), EPSILON);
431 ASSERT_NEAR(X_OFFSET + 120 * X_SCALE, event->getHistoricalX(1, 1), EPSILON);
432 ASSERT_NEAR(X_OFFSET + 210 * X_SCALE, event->getX(0), EPSILON);
433 ASSERT_NEAR(X_OFFSET + 220 * X_SCALE, event->getX(1), EPSILON);
434
435 ASSERT_NEAR(Y_OFFSET + 11 * Y_SCALE, event->getHistoricalY(0, 0), EPSILON);
436 ASSERT_NEAR(Y_OFFSET + 21 * Y_SCALE, event->getHistoricalY(1, 0), EPSILON);
437 ASSERT_NEAR(Y_OFFSET + 111 * Y_SCALE, event->getHistoricalY(0, 1), EPSILON);
438 ASSERT_NEAR(Y_OFFSET + 121 * Y_SCALE, event->getHistoricalY(1, 1), EPSILON);
439 ASSERT_NEAR(Y_OFFSET + 211 * Y_SCALE, event->getY(0), EPSILON);
440 ASSERT_NEAR(Y_OFFSET + 221 * Y_SCALE, event->getY(1), EPSILON);
Jeff Brown5912f952013-07-01 19:10:31 -0700441
442 ASSERT_EQ(12, event->getHistoricalPressure(0, 0));
443 ASSERT_EQ(22, event->getHistoricalPressure(1, 0));
444 ASSERT_EQ(112, event->getHistoricalPressure(0, 1));
445 ASSERT_EQ(122, event->getHistoricalPressure(1, 1));
446 ASSERT_EQ(212, event->getPressure(0));
447 ASSERT_EQ(222, event->getPressure(1));
448
449 ASSERT_EQ(13, event->getHistoricalSize(0, 0));
450 ASSERT_EQ(23, event->getHistoricalSize(1, 0));
451 ASSERT_EQ(113, event->getHistoricalSize(0, 1));
452 ASSERT_EQ(123, event->getHistoricalSize(1, 1));
453 ASSERT_EQ(213, event->getSize(0));
454 ASSERT_EQ(223, event->getSize(1));
455
456 ASSERT_EQ(14, event->getHistoricalTouchMajor(0, 0));
457 ASSERT_EQ(24, event->getHistoricalTouchMajor(1, 0));
458 ASSERT_EQ(114, event->getHistoricalTouchMajor(0, 1));
459 ASSERT_EQ(124, event->getHistoricalTouchMajor(1, 1));
460 ASSERT_EQ(214, event->getTouchMajor(0));
461 ASSERT_EQ(224, event->getTouchMajor(1));
462
463 ASSERT_EQ(15, event->getHistoricalTouchMinor(0, 0));
464 ASSERT_EQ(25, event->getHistoricalTouchMinor(1, 0));
465 ASSERT_EQ(115, event->getHistoricalTouchMinor(0, 1));
466 ASSERT_EQ(125, event->getHistoricalTouchMinor(1, 1));
467 ASSERT_EQ(215, event->getTouchMinor(0));
468 ASSERT_EQ(225, event->getTouchMinor(1));
469
470 ASSERT_EQ(16, event->getHistoricalToolMajor(0, 0));
471 ASSERT_EQ(26, event->getHistoricalToolMajor(1, 0));
472 ASSERT_EQ(116, event->getHistoricalToolMajor(0, 1));
473 ASSERT_EQ(126, event->getHistoricalToolMajor(1, 1));
474 ASSERT_EQ(216, event->getToolMajor(0));
475 ASSERT_EQ(226, event->getToolMajor(1));
476
477 ASSERT_EQ(17, event->getHistoricalToolMinor(0, 0));
478 ASSERT_EQ(27, event->getHistoricalToolMinor(1, 0));
479 ASSERT_EQ(117, event->getHistoricalToolMinor(0, 1));
480 ASSERT_EQ(127, event->getHistoricalToolMinor(1, 1));
481 ASSERT_EQ(217, event->getToolMinor(0));
482 ASSERT_EQ(227, event->getToolMinor(1));
483
Prabir Pradhan9eb02c02021-10-19 14:02:20 -0700484 // Calculate the orientation after scaling, keeping in mind that an orientation of 0 is "up",
485 // and the positive y direction is "down".
486 auto toScaledOrientation = [](float angle) {
487 const float x = sinf(angle) * X_SCALE;
488 const float y = -cosf(angle) * Y_SCALE;
489 return atan2f(x, -y);
490 };
491 ASSERT_EQ(toScaledOrientation(18), event->getHistoricalOrientation(0, 0));
492 ASSERT_EQ(toScaledOrientation(28), event->getHistoricalOrientation(1, 0));
493 ASSERT_EQ(toScaledOrientation(118), event->getHistoricalOrientation(0, 1));
494 ASSERT_EQ(toScaledOrientation(128), event->getHistoricalOrientation(1, 1));
495 ASSERT_EQ(toScaledOrientation(218), event->getOrientation(0));
496 ASSERT_EQ(toScaledOrientation(228), event->getOrientation(1));
Philip Quinnafb31282022-12-20 18:17:55 -0800497
498 ASSERT_TRUE(event->isResampled(0, 0));
499 ASSERT_FALSE(event->isResampled(1, 0));
500 ASSERT_TRUE(event->isResampled(0, 1));
501 ASSERT_TRUE(event->isResampled(1, 1));
502 ASSERT_FALSE(event->isResampled(0, 2));
503 ASSERT_FALSE(event->isResampled(1, 2));
Jeff Brown5912f952013-07-01 19:10:31 -0700504}
505
506TEST_F(MotionEventTest, Properties) {
507 MotionEvent event;
508
509 // Initialize, add samples and check properties.
510 initializeEventWithHistory(&event);
511 ASSERT_NO_FATAL_FAILURE(assertEqualsEventWithHistory(&event));
512
513 // Set source.
514 event.setSource(AINPUT_SOURCE_JOYSTICK);
Siarhei Vishniakou3826d472020-01-27 10:44:40 -0600515 ASSERT_EQ(AINPUT_SOURCE_JOYSTICK, event.getSource());
Jeff Brown5912f952013-07-01 19:10:31 -0700516
Siarhei Vishniakou777a10b2018-01-31 16:45:06 -0800517 // Set displayId.
518 constexpr int32_t newDisplayId = 2;
519 event.setDisplayId(newDisplayId);
520 ASSERT_EQ(newDisplayId, event.getDisplayId());
521
Jeff Brown5912f952013-07-01 19:10:31 -0700522 // Set action.
523 event.setAction(AMOTION_EVENT_ACTION_CANCEL);
524 ASSERT_EQ(AMOTION_EVENT_ACTION_CANCEL, event.getAction());
525
526 // Set meta state.
527 event.setMetaState(AMETA_CTRL_ON);
528 ASSERT_EQ(AMETA_CTRL_ON, event.getMetaState());
529}
530
531TEST_F(MotionEventTest, CopyFrom_KeepHistory) {
532 MotionEvent event;
533 initializeEventWithHistory(&event);
534
535 MotionEvent copy;
Harry Cutts82c791c2023-03-10 17:15:07 +0000536 copy.copyFrom(&event, /*keepHistory=*/true);
Jeff Brown5912f952013-07-01 19:10:31 -0700537
538 ASSERT_NO_FATAL_FAILURE(assertEqualsEventWithHistory(&event));
539}
540
541TEST_F(MotionEventTest, CopyFrom_DoNotKeepHistory) {
542 MotionEvent event;
543 initializeEventWithHistory(&event);
544
545 MotionEvent copy;
Harry Cutts82c791c2023-03-10 17:15:07 +0000546 copy.copyFrom(&event, /*keepHistory=*/false);
Jeff Brown5912f952013-07-01 19:10:31 -0700547
548 ASSERT_EQ(event.getPointerCount(), copy.getPointerCount());
549 ASSERT_EQ(0U, copy.getHistorySize());
550
551 ASSERT_EQ(event.getPointerId(0), copy.getPointerId(0));
552 ASSERT_EQ(event.getPointerId(1), copy.getPointerId(1));
553
554 ASSERT_EQ(event.getEventTime(), copy.getEventTime());
555
556 ASSERT_EQ(event.getX(0), copy.getX(0));
557}
558
559TEST_F(MotionEventTest, OffsetLocation) {
560 MotionEvent event;
561 initializeEventWithHistory(&event);
Prabir Pradhanadd8a4a2024-03-05 22:18:09 +0000562 const float xOffset = event.getRawXOffset();
563 const float yOffset = event.getRawYOffset();
Jeff Brown5912f952013-07-01 19:10:31 -0700564
565 event.offsetLocation(5.0f, -2.0f);
566
Prabir Pradhanadd8a4a2024-03-05 22:18:09 +0000567 ASSERT_EQ(xOffset + 5.0f, event.getRawXOffset());
568 ASSERT_EQ(yOffset - 2.0f, event.getRawYOffset());
Jeff Brown5912f952013-07-01 19:10:31 -0700569}
570
571TEST_F(MotionEventTest, Scale) {
572 MotionEvent event;
573 initializeEventWithHistory(&event);
Prabir Pradhan9eb02c02021-10-19 14:02:20 -0700574 const float unscaledOrientation = event.getOrientation(0);
Prabir Pradhanadd8a4a2024-03-05 22:18:09 +0000575 const float unscaledXOffset = event.getRawXOffset();
576 const float unscaledYOffset = event.getRawYOffset();
Jeff Brown5912f952013-07-01 19:10:31 -0700577
578 event.scale(2.0f);
579
Prabir Pradhanadd8a4a2024-03-05 22:18:09 +0000580 ASSERT_EQ(unscaledXOffset * 2, event.getRawXOffset());
581 ASSERT_EQ(unscaledYOffset * 2, event.getRawYOffset());
Jeff Brown5912f952013-07-01 19:10:31 -0700582
Prabir Pradhan00e029d2023-03-09 20:11:09 +0000583 ASSERT_NEAR((RAW_X_OFFSET + 210 * RAW_X_SCALE) * 2, event.getRawX(0), EPSILON);
584 ASSERT_NEAR((RAW_Y_OFFSET + 211 * RAW_Y_SCALE) * 2, event.getRawY(0), EPSILON);
585 ASSERT_NEAR((X_OFFSET + 210 * X_SCALE) * 2, event.getX(0), EPSILON);
586 ASSERT_NEAR((Y_OFFSET + 211 * Y_SCALE) * 2, event.getY(0), EPSILON);
Jeff Brown5912f952013-07-01 19:10:31 -0700587 ASSERT_EQ(212, event.getPressure(0));
588 ASSERT_EQ(213, event.getSize(0));
589 ASSERT_EQ(214 * 2, event.getTouchMajor(0));
590 ASSERT_EQ(215 * 2, event.getTouchMinor(0));
591 ASSERT_EQ(216 * 2, event.getToolMajor(0));
592 ASSERT_EQ(217 * 2, event.getToolMinor(0));
Prabir Pradhan9eb02c02021-10-19 14:02:20 -0700593 ASSERT_EQ(unscaledOrientation, event.getOrientation(0));
Jeff Brown5912f952013-07-01 19:10:31 -0700594}
595
596TEST_F(MotionEventTest, Parcel) {
597 Parcel parcel;
598
599 MotionEvent inEvent;
600 initializeEventWithHistory(&inEvent);
601 MotionEvent outEvent;
602
603 // Round trip.
604 inEvent.writeToParcel(&parcel);
605 parcel.setDataPosition(0);
606 outEvent.readFromParcel(&parcel);
607
608 ASSERT_NO_FATAL_FAILURE(assertEqualsEventWithHistory(&outEvent));
609}
610
chaviw9eaa22c2020-07-01 16:21:27 -0700611static void setRotationMatrix(std::array<float, 9>& matrix, float angle) {
Jeff Brown313eff72013-07-15 18:07:09 -0700612 float sin = sinf(angle);
613 float cos = cosf(angle);
614 matrix[0] = cos;
615 matrix[1] = -sin;
616 matrix[2] = 0;
617 matrix[3] = sin;
618 matrix[4] = cos;
619 matrix[5] = 0;
620 matrix[6] = 0;
621 matrix[7] = 0;
622 matrix[8] = 1.0f;
623}
624
Jeff Brown5912f952013-07-01 19:10:31 -0700625TEST_F(MotionEventTest, Transform) {
626 // Generate some points on a circle.
627 // Each point 'i' is a point on a circle of radius ROTATION centered at (3,2) at an angle
628 // of ARC * i degrees clockwise relative to the Y axis.
629 // The geometrical representation is irrelevant to the test, it's just easy to generate
630 // and check rotation. We set the orientation to the same angle.
631 // Coordinate system: down is increasing Y, right is increasing X.
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700632 static constexpr float PI_180 = float(M_PI / 180);
633 static constexpr float RADIUS = 10;
634 static constexpr float ARC = 36;
635 static constexpr float ROTATION = ARC * 2;
Jeff Brown5912f952013-07-01 19:10:31 -0700636
637 const size_t pointerCount = 11;
638 PointerProperties pointerProperties[pointerCount];
639 PointerCoords pointerCoords[pointerCount];
640 for (size_t i = 0; i < pointerCount; i++) {
641 float angle = float(i * ARC * PI_180);
642 pointerProperties[i].clear();
643 pointerProperties[i].id = i;
644 pointerCoords[i].clear();
645 pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_X, sinf(angle) * RADIUS + 3);
646 pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_Y, -cosf(angle) * RADIUS + 2);
647 pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, angle);
648 }
649 MotionEvent event;
chaviw9eaa22c2020-07-01 16:21:27 -0700650 ui::Transform identityTransform;
Harry Cutts82c791c2023-03-10 17:15:07 +0000651 event.initialize(InputEvent::nextId(), /*deviceId=*/0, AINPUT_SOURCE_TOUCHSCREEN, DISPLAY_ID,
652 INVALID_HMAC, AMOTION_EVENT_ACTION_MOVE, /*actionButton=*/0, /*flags=*/0,
653 AMOTION_EVENT_EDGE_FLAG_NONE, AMETA_NONE, /*buttonState=*/0,
654 MotionClassification::NONE, identityTransform, /*xPrecision=*/0,
655 /*yPrecision=*/0, /*xCursorPosition=*/3 + RADIUS, /*yCursorPosition=*/2,
656 identityTransform, /*downTime=*/0, /*eventTime=*/0, pointerCount,
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700657 pointerProperties, pointerCoords);
Jeff Brown5912f952013-07-01 19:10:31 -0700658 float originalRawX = 0 + 3;
659 float originalRawY = -RADIUS + 2;
660
661 // Check original raw X and Y assumption.
662 ASSERT_NEAR(originalRawX, event.getRawX(0), 0.001);
663 ASSERT_NEAR(originalRawY, event.getRawY(0), 0.001);
664
665 // Now translate the motion event so the circle's origin is at (0,0).
666 event.offsetLocation(-3, -2);
667
668 // Offsetting the location should preserve the raw X and Y of the first point.
669 ASSERT_NEAR(originalRawX, event.getRawX(0), 0.001);
670 ASSERT_NEAR(originalRawY, event.getRawY(0), 0.001);
671
672 // Apply a rotation about the origin by ROTATION degrees clockwise.
chaviw9eaa22c2020-07-01 16:21:27 -0700673 std::array<float, 9> matrix;
Jeff Brown313eff72013-07-15 18:07:09 -0700674 setRotationMatrix(matrix, ROTATION * PI_180);
675 event.transform(matrix);
Jeff Brown5912f952013-07-01 19:10:31 -0700676
677 // Check the points.
678 for (size_t i = 0; i < pointerCount; i++) {
679 float angle = float((i * ARC + ROTATION) * PI_180);
680 ASSERT_NEAR(sinf(angle) * RADIUS, event.getX(i), 0.001);
681 ASSERT_NEAR(-cosf(angle) * RADIUS, event.getY(i), 0.001);
682 ASSERT_NEAR(tanf(angle), tanf(event.getOrientation(i)), 0.1);
683 }
684
Garfield Tanab0ab9c2019-07-10 18:58:28 -0700685 // Check cursor positions. The original cursor position is at (3 + RADIUS, 2), where the center
686 // of the circle is (3, 2), so the cursor position is to the right of the center of the circle.
687 // The choice of triangular functions in this test defines the angle of rotation clockwise
688 // relative to the y-axis. Therefore the cursor position's angle is 90 degrees. Here we swap the
689 // triangular function so that we don't have to add the 90 degrees.
690 ASSERT_NEAR(cosf(PI_180 * ROTATION) * RADIUS, event.getXCursorPosition(), 0.001);
691 ASSERT_NEAR(sinf(PI_180 * ROTATION) * RADIUS, event.getYCursorPosition(), 0.001);
Garfield Tan00f511d2019-06-12 16:55:40 -0700692
Jeff Brown5912f952013-07-01 19:10:31 -0700693 // Applying the transformation should preserve the raw X and Y of the first point.
694 ASSERT_NEAR(originalRawX, event.getRawX(0), 0.001);
695 ASSERT_NEAR(originalRawY, event.getRawY(0), 0.001);
696}
697
Prabir Pradhan7e1ee562021-10-26 10:19:49 -0700698MotionEvent createMotionEvent(int32_t source, uint32_t action, float x, float y, float dx, float dy,
699 const ui::Transform& transform, const ui::Transform& rawTransform) {
Evan Roskyd4d4d802021-05-03 20:12:21 -0700700 std::vector<PointerProperties> pointerProperties;
Siarhei Vishniakou6d73f832022-07-21 17:27:03 -0700701 pointerProperties.push_back(PointerProperties{/*id=*/0, ToolType::FINGER});
Evan Roskyd4d4d802021-05-03 20:12:21 -0700702 std::vector<PointerCoords> pointerCoords;
703 pointerCoords.emplace_back().clear();
704 pointerCoords.back().setAxisValue(AMOTION_EVENT_AXIS_X, x);
705 pointerCoords.back().setAxisValue(AMOTION_EVENT_AXIS_Y, y);
Prabir Pradhanc6523582021-05-14 18:02:55 -0700706 pointerCoords.back().setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, dx);
707 pointerCoords.back().setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, dy);
Evan Roskyd4d4d802021-05-03 20:12:21 -0700708 nsecs_t eventTime = systemTime(SYSTEM_TIME_MONOTONIC);
709 MotionEvent event;
Prabir Pradhan7e1ee562021-10-26 10:19:49 -0700710 event.initialize(InputEvent::nextId(), /* deviceId */ 1, source,
711 /* displayId */ 0, INVALID_HMAC, action,
Evan Roskyd4d4d802021-05-03 20:12:21 -0700712 /* actionButton */ 0, /* flags */ 0, /* edgeFlags */ 0, AMETA_NONE,
713 /* buttonState */ 0, MotionClassification::NONE, transform,
714 /* xPrecision */ 0, /* yPrecision */ 0, AMOTION_EVENT_INVALID_CURSOR_POSITION,
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700715 AMOTION_EVENT_INVALID_CURSOR_POSITION, rawTransform, eventTime, eventTime,
716 pointerCoords.size(), pointerProperties.data(), pointerCoords.data());
Evan Roskyd4d4d802021-05-03 20:12:21 -0700717 return event;
718}
Evan Rosky84f07f02021-04-16 10:42:42 -0700719
Prabir Pradhan7e1ee562021-10-26 10:19:49 -0700720MotionEvent createTouchDownEvent(float x, float y, float dx, float dy,
721 const ui::Transform& transform,
722 const ui::Transform& rawTransform) {
723 return createMotionEvent(AINPUT_SOURCE_TOUCHSCREEN, AMOTION_EVENT_ACTION_DOWN, x, y, dx, dy,
724 transform, rawTransform);
725}
726
Evan Roskyd4d4d802021-05-03 20:12:21 -0700727TEST_F(MotionEventTest, ApplyTransform) {
728 // Create a rotate-90 transform with an offset (like a window which isn't fullscreen).
729 ui::Transform identity;
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700730 ui::Transform transform(ui::Transform::ROT_90, 800, 400);
731 transform.set(transform.tx() + 20, transform.ty() + 40);
732 ui::Transform rawTransform(ui::Transform::ROT_90, 800, 400);
733 MotionEvent event = createTouchDownEvent(60, 100, 42, 96, transform, rawTransform);
Evan Roskyd4d4d802021-05-03 20:12:21 -0700734 ASSERT_EQ(700, event.getRawX(0));
735 ASSERT_EQ(60, event.getRawY(0));
736 ASSERT_NE(event.getRawX(0), event.getX(0));
737 ASSERT_NE(event.getRawY(0), event.getY(0));
Prabir Pradhanc6523582021-05-14 18:02:55 -0700738 // Relative values should be rotated but not translated.
739 ASSERT_EQ(-96, event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, 0));
740 ASSERT_EQ(42, event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, 0));
Evan Roskyd4d4d802021-05-03 20:12:21 -0700741
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700742 MotionEvent changedEvent = createTouchDownEvent(60, 100, 42, 96, identity, identity);
743 const std::array<float, 9> rowMajor{transform[0][0], transform[1][0], transform[2][0],
744 transform[0][1], transform[1][1], transform[2][1],
745 transform[0][2], transform[1][2], transform[2][2]};
Evan Roskyd4d4d802021-05-03 20:12:21 -0700746 changedEvent.applyTransform(rowMajor);
747
748 // transformContent effectively rotates the raw coordinates, so those should now include
Prabir Pradhanc6523582021-05-14 18:02:55 -0700749 // both rotation AND offset.
Evan Roskyd4d4d802021-05-03 20:12:21 -0700750 ASSERT_EQ(720, changedEvent.getRawX(0));
751 ASSERT_EQ(100, changedEvent.getRawY(0));
Prabir Pradhanc6523582021-05-14 18:02:55 -0700752 // Relative values should be rotated but not translated.
753 ASSERT_EQ(-96, event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, 0));
754 ASSERT_EQ(42, event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, 0));
Evan Roskyd4d4d802021-05-03 20:12:21 -0700755
Prabir Pradhanc6523582021-05-14 18:02:55 -0700756 // The transformed output should be the same then.
Evan Roskyd4d4d802021-05-03 20:12:21 -0700757 ASSERT_NEAR(event.getX(0), changedEvent.getX(0), 0.001);
758 ASSERT_NEAR(event.getY(0), changedEvent.getY(0), 0.001);
Prabir Pradhanc6523582021-05-14 18:02:55 -0700759 ASSERT_NEAR(event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, 0),
760 changedEvent.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, 0), 0.001);
761 ASSERT_NEAR(event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, 0),
762 changedEvent.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, 0), 0.001);
Evan Roskyd4d4d802021-05-03 20:12:21 -0700763}
764
Prabir Pradhan7e1ee562021-10-26 10:19:49 -0700765TEST_F(MotionEventTest, JoystickAndTouchpadAreNotTransformed) {
Prabir Pradhan208360b2022-06-24 18:37:04 +0000766 constexpr static std::array kNonTransformedSources =
767 {std::pair(AINPUT_SOURCE_TOUCHPAD, AMOTION_EVENT_ACTION_DOWN),
768 std::pair(AINPUT_SOURCE_JOYSTICK, AMOTION_EVENT_ACTION_MOVE),
769 std::pair(AINPUT_SOURCE_MOUSE_RELATIVE, AMOTION_EVENT_ACTION_MOVE)};
Prabir Pradhan7e1ee562021-10-26 10:19:49 -0700770 // Create a rotate-90 transform with an offset (like a window which isn't fullscreen).
771 ui::Transform transform(ui::Transform::ROT_90, 800, 400);
772 transform.set(transform.tx() + 20, transform.ty() + 40);
773
774 for (const auto& [source, action] : kNonTransformedSources) {
775 const MotionEvent event =
776 createMotionEvent(source, action, 60, 100, 0, 0, transform, transform);
777
778 // These events should not be transformed in any way.
779 ASSERT_EQ(60, event.getX(0));
780 ASSERT_EQ(100, event.getY(0));
781 ASSERT_EQ(event.getRawX(0), event.getX(0));
782 ASSERT_EQ(event.getRawY(0), event.getY(0));
783 }
784}
785
Prabir Pradhan9f388812021-05-13 16:54:53 -0700786TEST_F(MotionEventTest, NonPointerSourcesAreNotTranslated) {
Prabir Pradhan7e1ee562021-10-26 10:19:49 -0700787 constexpr static std::array kNonPointerSources = {std::pair(AINPUT_SOURCE_TRACKBALL,
788 AMOTION_EVENT_ACTION_DOWN),
Prabir Pradhan208360b2022-06-24 18:37:04 +0000789 std::pair(AINPUT_SOURCE_TOUCH_NAVIGATION,
Prabir Pradhan7e1ee562021-10-26 10:19:49 -0700790 AMOTION_EVENT_ACTION_MOVE)};
791 // Create a rotate-90 transform with an offset (like a window which isn't fullscreen).
792 ui::Transform transform(ui::Transform::ROT_90, 800, 400);
793 transform.set(transform.tx() + 20, transform.ty() + 40);
794
795 for (const auto& [source, action] : kNonPointerSources) {
796 const MotionEvent event =
797 createMotionEvent(source, action, 60, 100, 42, 96, transform, transform);
Prabir Pradhan9f388812021-05-13 16:54:53 -0700798
799 // Since this event comes from a non-pointer source, it should include rotation but not
800 // translation/offset.
801 ASSERT_EQ(-100, event.getX(0));
802 ASSERT_EQ(60, event.getY(0));
803 ASSERT_EQ(event.getRawX(0), event.getX(0));
804 ASSERT_EQ(event.getRawY(0), event.getY(0));
805 }
806}
807
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700808TEST_F(MotionEventTest, AxesAreCorrectlyTransformed) {
809 const ui::Transform identity;
810 ui::Transform transform;
811 transform.set({1.1, -2.2, 3.3, -4.4, 5.5, -6.6, 0, 0, 1});
812 ui::Transform rawTransform;
813 rawTransform.set({-6.6, 5.5, -4.4, 3.3, -2.2, 1.1, 0, 0, 1});
814 auto transformWithoutTranslation = [](const ui::Transform& t, float x, float y) {
815 auto newPoint = t.transform(x, y);
816 auto newOrigin = t.transform(0, 0);
817 return newPoint - newOrigin;
818 };
Evan Rosky84f07f02021-04-16 10:42:42 -0700819
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700820 const MotionEvent event = createTouchDownEvent(60, 100, 42, 96, transform, rawTransform);
Evan Rosky84f07f02021-04-16 10:42:42 -0700821
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700822 // The x and y axes should have the window transform applied.
823 const auto newPoint = transform.transform(60, 100);
Prabir Pradhan00e029d2023-03-09 20:11:09 +0000824 ASSERT_NEAR(newPoint.x, event.getX(0), EPSILON);
825 ASSERT_NEAR(newPoint.y, event.getY(0), EPSILON);
Evan Rosky84f07f02021-04-16 10:42:42 -0700826
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700827 // The raw values should have the display transform applied.
828 const auto raw = rawTransform.transform(60, 100);
Prabir Pradhan00e029d2023-03-09 20:11:09 +0000829 ASSERT_NEAR(raw.x, event.getRawX(0), EPSILON);
830 ASSERT_NEAR(raw.y, event.getRawY(0), EPSILON);
Evan Rosky09576692021-07-01 12:22:09 -0700831
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700832 // Relative values should have the window transform applied without any translation.
833 const auto rel = transformWithoutTranslation(transform, 42, 96);
Prabir Pradhan00e029d2023-03-09 20:11:09 +0000834 ASSERT_NEAR(rel.x, event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, 0), EPSILON);
835 ASSERT_NEAR(rel.y, event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, 0), EPSILON);
Evan Rosky84f07f02021-04-16 10:42:42 -0700836}
837
Siarhei Vishniakou16a2e302019-01-14 19:21:45 -0800838TEST_F(MotionEventTest, Initialize_SetsClassification) {
839 std::array<MotionClassification, 3> classifications = {
840 MotionClassification::NONE,
841 MotionClassification::AMBIGUOUS_GESTURE,
842 MotionClassification::DEEP_PRESS,
843 };
844
845 MotionEvent event;
846 constexpr size_t pointerCount = 1;
847 PointerProperties pointerProperties[pointerCount];
848 PointerCoords pointerCoords[pointerCount];
849 for (size_t i = 0; i < pointerCount; i++) {
850 pointerProperties[i].clear();
851 pointerProperties[i].id = i;
852 pointerCoords[i].clear();
853 }
854
chaviw9eaa22c2020-07-01 16:21:27 -0700855 ui::Transform identityTransform;
Siarhei Vishniakou16a2e302019-01-14 19:21:45 -0800856 for (MotionClassification classification : classifications) {
Harry Cutts82c791c2023-03-10 17:15:07 +0000857 event.initialize(InputEvent::nextId(), /*deviceId=*/0, AINPUT_SOURCE_TOUCHSCREEN,
Garfield Tan4cc839f2020-01-24 11:26:14 -0800858 DISPLAY_ID, INVALID_HMAC, AMOTION_EVENT_ACTION_DOWN, 0, 0,
chaviw9eaa22c2020-07-01 16:21:27 -0700859 AMOTION_EVENT_EDGE_FLAG_NONE, AMETA_NONE, 0, classification,
860 identityTransform, 0, 0, AMOTION_EVENT_INVALID_CURSOR_POSITION,
Harry Cutts82c791c2023-03-10 17:15:07 +0000861 AMOTION_EVENT_INVALID_CURSOR_POSITION, identityTransform, /*downTime=*/0,
862 /*eventTime=*/0, pointerCount, pointerProperties, pointerCoords);
Siarhei Vishniakou16a2e302019-01-14 19:21:45 -0800863 ASSERT_EQ(classification, event.getClassification());
864 }
865}
866
Garfield Tan00f511d2019-06-12 16:55:40 -0700867TEST_F(MotionEventTest, Initialize_SetsCursorPosition) {
868 MotionEvent event;
869 constexpr size_t pointerCount = 1;
870 PointerProperties pointerProperties[pointerCount];
871 PointerCoords pointerCoords[pointerCount];
872 for (size_t i = 0; i < pointerCount; i++) {
873 pointerProperties[i].clear();
874 pointerProperties[i].id = i;
875 pointerCoords[i].clear();
876 }
877
chaviw9eaa22c2020-07-01 16:21:27 -0700878 ui::Transform identityTransform;
Harry Cutts82c791c2023-03-10 17:15:07 +0000879 event.initialize(InputEvent::nextId(), /*deviceId=*/0, AINPUT_SOURCE_MOUSE, DISPLAY_ID,
Garfield Tan4cc839f2020-01-24 11:26:14 -0800880 INVALID_HMAC, AMOTION_EVENT_ACTION_DOWN, 0, 0, AMOTION_EVENT_EDGE_FLAG_NONE,
chaviw9eaa22c2020-07-01 16:21:27 -0700881 AMETA_NONE, 0, MotionClassification::NONE, identityTransform, 0, 0,
Harry Cutts82c791c2023-03-10 17:15:07 +0000882 /*xCursorPosition=*/280, /*yCursorPosition=*/540, identityTransform,
883 /*downTime=*/0, /*eventTime=*/0, pointerCount, pointerProperties,
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700884 pointerCoords);
Garfield Tan00f511d2019-06-12 16:55:40 -0700885 event.offsetLocation(20, 60);
886 ASSERT_EQ(280, event.getRawXCursorPosition());
887 ASSERT_EQ(540, event.getRawYCursorPosition());
888 ASSERT_EQ(300, event.getXCursorPosition());
889 ASSERT_EQ(600, event.getYCursorPosition());
890}
891
Garfield Tan937bb832019-07-25 17:48:31 -0700892TEST_F(MotionEventTest, SetCursorPosition) {
893 MotionEvent event;
894 initializeEventWithHistory(&event);
895 event.setSource(AINPUT_SOURCE_MOUSE);
896
897 event.setCursorPosition(3, 4);
898 ASSERT_EQ(3, event.getXCursorPosition());
899 ASSERT_EQ(4, event.getYCursorPosition());
900}
901
Prabir Pradhan00e029d2023-03-09 20:11:09 +0000902TEST_F(MotionEventTest, CoordinatesAreRoundedAppropriately) {
903 // These are specifically integral values, since we are testing for rounding.
904 const vec2 EXPECTED{400.f, 700.f};
905
906 // Pick a transform such that transforming the point with its inverse and bringing that
907 // back to the original coordinate space results in a non-zero error amount due to the
908 // nature of floating point arithmetics. This can happen when the display is scaled.
909 // For example, the 'adb shell wm size' command can be used to set an override for the
910 // logical display size, which could result in the display being scaled.
911 constexpr float scale = 720.f / 1080.f;
912 ui::Transform transform;
913 transform.set(scale, 0, 0, scale);
914 ASSERT_NE(EXPECTED, transform.transform(transform.inverse().transform(EXPECTED)));
915
916 // Store the inverse-transformed values in the motion event.
917 const vec2 rawCoords = transform.inverse().transform(EXPECTED);
918 PointerCoords pc{};
919 pc.setAxisValue(AMOTION_EVENT_AXIS_X, rawCoords.x);
920 pc.setAxisValue(AMOTION_EVENT_AXIS_Y, rawCoords.y);
921 PointerProperties pp{};
922 MotionEvent event;
923 event.initialize(InputEvent::nextId(), 2, AINPUT_SOURCE_TOUCHSCREEN, DISPLAY_ID, HMAC,
924 AMOTION_EVENT_ACTION_MOVE, 0, AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED,
925 AMOTION_EVENT_EDGE_FLAG_TOP, AMETA_ALT_ON, AMOTION_EVENT_BUTTON_PRIMARY,
926 MotionClassification::NONE, transform, 2.0f, 2.1f, rawCoords.x, rawCoords.y,
927 transform, ARBITRARY_DOWN_TIME, ARBITRARY_EVENT_TIME, 1, &pp, &pc);
928
929 // When using the getters from the MotionEvent to obtain the coordinates, the transformed
930 // values should be rounded by an appropriate amount so that they now precisely equal the
931 // original coordinates.
932 ASSERT_EQ(EXPECTED.x, event.getX(0));
933 ASSERT_EQ(EXPECTED.y, event.getY(0));
934 ASSERT_EQ(EXPECTED.x, event.getRawX(0));
935 ASSERT_EQ(EXPECTED.y, event.getRawY(0));
936 ASSERT_EQ(EXPECTED.x, event.getXCursorPosition());
937 ASSERT_EQ(EXPECTED.y, event.getYCursorPosition());
938}
939
Jeff Brown5912f952013-07-01 19:10:31 -0700940} // namespace android