blob: 7e7dfd5416d15d7c39ae6f3060e9d424d4f7d52c [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
Siarhei Vishniakou9c858ac2020-01-23 14:20:11 -060032class BaseTest : public testing::Test {
33protected:
34 static constexpr std::array<uint8_t, 32> HMAC = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
35 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
36 22, 23, 24, 25, 26, 27, 28, 29, 30, 31};
37};
Jeff Brown5912f952013-07-01 19:10:31 -070038
39// --- PointerCoordsTest ---
40
41class PointerCoordsTest : public BaseTest {
42};
43
44TEST_F(PointerCoordsTest, ClearSetsBitsToZero) {
45 PointerCoords coords;
46 coords.clear();
47
48 ASSERT_EQ(0ULL, coords.bits);
49}
50
51TEST_F(PointerCoordsTest, AxisValues) {
Jeff Brown5912f952013-07-01 19:10:31 -070052 PointerCoords coords;
53 coords.clear();
54
55 // Check invariants when no axes are present.
56 ASSERT_EQ(0, coords.getAxisValue(0))
57 << "getAxisValue should return zero because axis is not present";
58 ASSERT_EQ(0, coords.getAxisValue(1))
59 << "getAxisValue should return zero because axis is not present";
60
61 // Set first axis.
62 ASSERT_EQ(OK, coords.setAxisValue(1, 5));
Jeff Brown5912f952013-07-01 19:10:31 -070063 ASSERT_EQ(5, coords.values[0]);
Narayan Kamathb8290c22014-05-06 11:31:37 +010064 ASSERT_EQ(0x4000000000000000ULL, coords.bits);
Jeff Brown5912f952013-07-01 19:10:31 -070065
66 ASSERT_EQ(0, coords.getAxisValue(0))
67 << "getAxisValue should return zero because axis is not present";
68 ASSERT_EQ(5, coords.getAxisValue(1))
69 << "getAxisValue should return value of axis";
70
71 // Set an axis with a higher id than all others. (appending value at the end)
72 ASSERT_EQ(OK, coords.setAxisValue(3, 2));
Narayan Kamathb8290c22014-05-06 11:31:37 +010073 ASSERT_EQ(0x5000000000000000ULL, coords.bits);
Jeff Brown5912f952013-07-01 19:10:31 -070074 ASSERT_EQ(5, coords.values[0]);
75 ASSERT_EQ(2, coords.values[1]);
76
77 ASSERT_EQ(0, coords.getAxisValue(0))
78 << "getAxisValue should return zero because axis is not present";
79 ASSERT_EQ(5, coords.getAxisValue(1))
80 << "getAxisValue should return value of axis";
81 ASSERT_EQ(0, coords.getAxisValue(2))
82 << "getAxisValue should return zero because axis is not present";
83 ASSERT_EQ(2, coords.getAxisValue(3))
84 << "getAxisValue should return value of axis";
85
86 // Set an axis with an id lower than all others. (prepending value at beginning)
87 ASSERT_EQ(OK, coords.setAxisValue(0, 4));
Narayan Kamathb8290c22014-05-06 11:31:37 +010088 ASSERT_EQ(0xd000000000000000ULL, coords.bits);
Jeff Brown5912f952013-07-01 19:10:31 -070089 ASSERT_EQ(4, coords.values[0]);
90 ASSERT_EQ(5, coords.values[1]);
91 ASSERT_EQ(2, coords.values[2]);
92
93 ASSERT_EQ(4, coords.getAxisValue(0))
94 << "getAxisValue should return value of axis";
95 ASSERT_EQ(5, coords.getAxisValue(1))
96 << "getAxisValue should return value of axis";
97 ASSERT_EQ(0, coords.getAxisValue(2))
98 << "getAxisValue should return zero because axis is not present";
99 ASSERT_EQ(2, coords.getAxisValue(3))
100 << "getAxisValue should return value of axis";
101
102 // Set an axis with an id between the others. (inserting value in the middle)
103 ASSERT_EQ(OK, coords.setAxisValue(2, 1));
Narayan Kamathb8290c22014-05-06 11:31:37 +0100104 ASSERT_EQ(0xf000000000000000ULL, coords.bits);
Jeff Brown5912f952013-07-01 19:10:31 -0700105 ASSERT_EQ(4, coords.values[0]);
106 ASSERT_EQ(5, coords.values[1]);
107 ASSERT_EQ(1, coords.values[2]);
108 ASSERT_EQ(2, coords.values[3]);
109
110 ASSERT_EQ(4, coords.getAxisValue(0))
111 << "getAxisValue should return value of axis";
112 ASSERT_EQ(5, coords.getAxisValue(1))
113 << "getAxisValue should return value of axis";
114 ASSERT_EQ(1, coords.getAxisValue(2))
115 << "getAxisValue should return value of axis";
116 ASSERT_EQ(2, coords.getAxisValue(3))
117 << "getAxisValue should return value of axis";
118
119 // Set an existing axis value in place.
120 ASSERT_EQ(OK, coords.setAxisValue(1, 6));
Narayan Kamathb8290c22014-05-06 11:31:37 +0100121 ASSERT_EQ(0xf000000000000000ULL, coords.bits);
Jeff Brown5912f952013-07-01 19:10:31 -0700122 ASSERT_EQ(4, coords.values[0]);
123 ASSERT_EQ(6, coords.values[1]);
124 ASSERT_EQ(1, coords.values[2]);
125 ASSERT_EQ(2, coords.values[3]);
126
127 ASSERT_EQ(4, coords.getAxisValue(0))
128 << "getAxisValue should return value of axis";
129 ASSERT_EQ(6, coords.getAxisValue(1))
130 << "getAxisValue should return value of axis";
131 ASSERT_EQ(1, coords.getAxisValue(2))
132 << "getAxisValue should return value of axis";
133 ASSERT_EQ(2, coords.getAxisValue(3))
134 << "getAxisValue should return value of axis";
135
136 // Set maximum number of axes.
137 for (size_t axis = 4; axis < PointerCoords::MAX_AXES; axis++) {
138 ASSERT_EQ(OK, coords.setAxisValue(axis, axis));
139 }
140 ASSERT_EQ(PointerCoords::MAX_AXES, __builtin_popcountll(coords.bits));
141
142 // Try to set one more axis beyond maximum number.
143 // Ensure bits are unchanged.
144 ASSERT_EQ(NO_MEMORY, coords.setAxisValue(PointerCoords::MAX_AXES, 100));
145 ASSERT_EQ(PointerCoords::MAX_AXES, __builtin_popcountll(coords.bits));
146}
147
148TEST_F(PointerCoordsTest, Parcel) {
149 Parcel parcel;
150
151 PointerCoords inCoords;
152 inCoords.clear();
153 PointerCoords outCoords;
154
155 // Round trip with empty coords.
156 inCoords.writeToParcel(&parcel);
157 parcel.setDataPosition(0);
158 outCoords.readFromParcel(&parcel);
159
160 ASSERT_EQ(0ULL, outCoords.bits);
161
162 // Round trip with some values.
163 parcel.freeData();
164 inCoords.setAxisValue(2, 5);
165 inCoords.setAxisValue(5, 8);
166
167 inCoords.writeToParcel(&parcel);
168 parcel.setDataPosition(0);
169 outCoords.readFromParcel(&parcel);
170
171 ASSERT_EQ(outCoords.bits, inCoords.bits);
172 ASSERT_EQ(outCoords.values[0], inCoords.values[0]);
173 ASSERT_EQ(outCoords.values[1], inCoords.values[1]);
174}
175
176
177// --- KeyEventTest ---
178
179class KeyEventTest : public BaseTest {
180};
181
182TEST_F(KeyEventTest, Properties) {
183 KeyEvent event;
184
185 // Initialize and get properties.
Siarhei Vishniakou9c858ac2020-01-23 14:20:11 -0600186 constexpr nsecs_t ARBITRARY_DOWN_TIME = 1;
187 constexpr nsecs_t ARBITRARY_EVENT_TIME = 2;
Garfield Tan4cc839f2020-01-24 11:26:14 -0800188 const int32_t id = InputEvent::nextId();
189 event.initialize(id, 2, AINPUT_SOURCE_GAMEPAD, DISPLAY_ID, HMAC, AKEY_EVENT_ACTION_DOWN,
Siarhei Vishniakou9c858ac2020-01-23 14:20:11 -0600190 AKEY_EVENT_FLAG_FROM_SYSTEM, AKEYCODE_BUTTON_X, 121, AMETA_ALT_ON, 1,
191 ARBITRARY_DOWN_TIME, ARBITRARY_EVENT_TIME);
Jeff Brown5912f952013-07-01 19:10:31 -0700192
Garfield Tan4cc839f2020-01-24 11:26:14 -0800193 ASSERT_EQ(id, event.getId());
Jeff Brown5912f952013-07-01 19:10:31 -0700194 ASSERT_EQ(AINPUT_EVENT_TYPE_KEY, event.getType());
195 ASSERT_EQ(2, event.getDeviceId());
Siarhei Vishniakou3826d472020-01-27 10:44:40 -0600196 ASSERT_EQ(AINPUT_SOURCE_GAMEPAD, event.getSource());
Siarhei Vishniakoua62a8dd2018-06-08 21:17:33 +0100197 ASSERT_EQ(DISPLAY_ID, event.getDisplayId());
Siarhei Vishniakou9c858ac2020-01-23 14:20:11 -0600198 EXPECT_EQ(HMAC, event.getHmac());
Jeff Brown5912f952013-07-01 19:10:31 -0700199 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, event.getAction());
200 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, event.getFlags());
201 ASSERT_EQ(AKEYCODE_BUTTON_X, event.getKeyCode());
202 ASSERT_EQ(121, event.getScanCode());
203 ASSERT_EQ(AMETA_ALT_ON, event.getMetaState());
204 ASSERT_EQ(1, event.getRepeatCount());
205 ASSERT_EQ(ARBITRARY_DOWN_TIME, event.getDownTime());
206 ASSERT_EQ(ARBITRARY_EVENT_TIME, event.getEventTime());
207
208 // Set source.
209 event.setSource(AINPUT_SOURCE_JOYSTICK);
Siarhei Vishniakou3826d472020-01-27 10:44:40 -0600210 ASSERT_EQ(AINPUT_SOURCE_JOYSTICK, event.getSource());
Siarhei Vishniakoua62a8dd2018-06-08 21:17:33 +0100211
212 // Set display id.
213 constexpr int32_t newDisplayId = 2;
214 event.setDisplayId(newDisplayId);
215 ASSERT_EQ(newDisplayId, event.getDisplayId());
Jeff Brown5912f952013-07-01 19:10:31 -0700216}
217
218
219// --- MotionEventTest ---
220
221class MotionEventTest : public BaseTest {
222protected:
Siarhei Vishniakou9c858ac2020-01-23 14:20:11 -0600223 static constexpr nsecs_t ARBITRARY_DOWN_TIME = 1;
224 static constexpr nsecs_t ARBITRARY_EVENT_TIME = 2;
225 static constexpr float X_SCALE = 2.0;
226 static constexpr float Y_SCALE = 3.0;
227 static constexpr float X_OFFSET = 1;
228 static constexpr float Y_OFFSET = 1.1;
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700229 static constexpr float RAW_X_SCALE = 4.0;
230 static constexpr float RAW_Y_SCALE = -5.0;
231 static constexpr float RAW_X_OFFSET = 12;
232 static constexpr float RAW_Y_OFFSET = -41.1;
Jeff Brown5912f952013-07-01 19:10:31 -0700233
Prabir Pradhan7e1443f2021-07-23 21:01:55 +0000234 static const std::optional<bool> INITIAL_PER_WINDOW_INPUT_ROTATION_FLAG_VALUE;
235
Garfield Tan4cc839f2020-01-24 11:26:14 -0800236 int32_t mId;
chaviw9eaa22c2020-07-01 16:21:27 -0700237 ui::Transform mTransform;
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700238 ui::Transform mRawTransform;
Garfield Tan4cc839f2020-01-24 11:26:14 -0800239
Prabir Pradhan7e1443f2021-07-23 21:01:55 +0000240 void SetUp() override;
241 void TearDown() override;
242
Jeff Brown5912f952013-07-01 19:10:31 -0700243 void initializeEventWithHistory(MotionEvent* event);
244 void assertEqualsEventWithHistory(const MotionEvent* event);
245};
246
Prabir Pradhan7e1443f2021-07-23 21:01:55 +0000247const std::optional<bool> MotionEventTest::INITIAL_PER_WINDOW_INPUT_ROTATION_FLAG_VALUE =
248 !base::GetProperty("persist.debug.per_window_input_rotation", "").empty()
249 ? std::optional(base::GetBoolProperty("persist.debug.per_window_input_rotation", false))
250 : std::nullopt;
251
252void MotionEventTest::SetUp() {
253 // Ensure per_window_input_rotation is enabled.
254 base::SetProperty("persist.debug.per_window_input_rotation", "true");
255}
256
257void MotionEventTest::TearDown() {
258 const auto val = INITIAL_PER_WINDOW_INPUT_ROTATION_FLAG_VALUE.has_value()
259 ? (*INITIAL_PER_WINDOW_INPUT_ROTATION_FLAG_VALUE ? "true" : "false")
260 : "";
261 base::SetProperty("persist.debug.per_window_input_rotation", val);
262}
Jeff Brown5912f952013-07-01 19:10:31 -0700263
264void MotionEventTest::initializeEventWithHistory(MotionEvent* event) {
Garfield Tan4cc839f2020-01-24 11:26:14 -0800265 mId = InputEvent::nextId();
chaviw9eaa22c2020-07-01 16:21:27 -0700266 mTransform.set({X_SCALE, 0, X_OFFSET, 0, Y_SCALE, Y_OFFSET, 0, 0, 1});
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700267 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 -0800268
Jeff Brown5912f952013-07-01 19:10:31 -0700269 PointerProperties pointerProperties[2];
270 pointerProperties[0].clear();
271 pointerProperties[0].id = 1;
272 pointerProperties[0].toolType = AMOTION_EVENT_TOOL_TYPE_FINGER;
273 pointerProperties[1].clear();
274 pointerProperties[1].id = 2;
275 pointerProperties[1].toolType = AMOTION_EVENT_TOOL_TYPE_STYLUS;
276
277 PointerCoords pointerCoords[2];
278 pointerCoords[0].clear();
279 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X, 10);
280 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, 11);
281 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 12);
282 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 13);
283 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 14);
284 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 15);
285 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 16);
286 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 17);
287 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 18);
288 pointerCoords[1].clear();
289 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_X, 20);
290 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_Y, 21);
291 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 22);
292 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 23);
293 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 24);
294 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 25);
295 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 26);
296 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 27);
297 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 28);
Garfield Tan4cc839f2020-01-24 11:26:14 -0800298 event->initialize(mId, 2, AINPUT_SOURCE_TOUCHSCREEN, DISPLAY_ID, HMAC,
299 AMOTION_EVENT_ACTION_MOVE, 0, AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED,
300 AMOTION_EVENT_EDGE_FLAG_TOP, AMETA_ALT_ON, AMOTION_EVENT_BUTTON_PRIMARY,
chaviw9eaa22c2020-07-01 16:21:27 -0700301 MotionClassification::NONE, mTransform, 2.0f, 2.1f,
Siarhei Vishniakou9c858ac2020-01-23 14:20:11 -0600302 AMOTION_EVENT_INVALID_CURSOR_POSITION, AMOTION_EVENT_INVALID_CURSOR_POSITION,
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700303 mRawTransform, ARBITRARY_DOWN_TIME, ARBITRARY_EVENT_TIME, 2,
304 pointerProperties, pointerCoords);
Jeff Brown5912f952013-07-01 19:10:31 -0700305
306 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X, 110);
307 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, 111);
308 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 112);
309 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 113);
310 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 114);
311 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 115);
312 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 116);
313 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 117);
314 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 118);
315 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_X, 120);
316 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_Y, 121);
317 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 122);
318 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 123);
319 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 124);
320 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 125);
321 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 126);
322 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 127);
323 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 128);
324 event->addSample(ARBITRARY_EVENT_TIME + 1, pointerCoords);
325
326 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X, 210);
327 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, 211);
328 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 212);
329 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 213);
330 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 214);
331 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 215);
332 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 216);
333 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 217);
334 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 218);
335 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_X, 220);
336 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_Y, 221);
337 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 222);
338 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 223);
339 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 224);
340 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 225);
341 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 226);
342 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 227);
343 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 228);
344 event->addSample(ARBITRARY_EVENT_TIME + 2, pointerCoords);
345}
346
347void MotionEventTest::assertEqualsEventWithHistory(const MotionEvent* event) {
348 // Check properties.
Garfield Tan4cc839f2020-01-24 11:26:14 -0800349 ASSERT_EQ(mId, event->getId());
Jeff Brown5912f952013-07-01 19:10:31 -0700350 ASSERT_EQ(AINPUT_EVENT_TYPE_MOTION, event->getType());
351 ASSERT_EQ(2, event->getDeviceId());
Siarhei Vishniakou3826d472020-01-27 10:44:40 -0600352 ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, event->getSource());
Siarhei Vishniakou777a10b2018-01-31 16:45:06 -0800353 ASSERT_EQ(DISPLAY_ID, event->getDisplayId());
Siarhei Vishniakou9c858ac2020-01-23 14:20:11 -0600354 EXPECT_EQ(HMAC, event->getHmac());
Jeff Brown5912f952013-07-01 19:10:31 -0700355 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, event->getAction());
356 ASSERT_EQ(AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED, event->getFlags());
357 ASSERT_EQ(AMOTION_EVENT_EDGE_FLAG_TOP, event->getEdgeFlags());
358 ASSERT_EQ(AMETA_ALT_ON, event->getMetaState());
359 ASSERT_EQ(AMOTION_EVENT_BUTTON_PRIMARY, event->getButtonState());
Siarhei Vishniakou16a2e302019-01-14 19:21:45 -0800360 ASSERT_EQ(MotionClassification::NONE, event->getClassification());
chaviw9eaa22c2020-07-01 16:21:27 -0700361 EXPECT_EQ(mTransform, event->getTransform());
Jeff Brown5912f952013-07-01 19:10:31 -0700362 ASSERT_EQ(X_OFFSET, event->getXOffset());
363 ASSERT_EQ(Y_OFFSET, event->getYOffset());
364 ASSERT_EQ(2.0f, event->getXPrecision());
365 ASSERT_EQ(2.1f, event->getYPrecision());
366 ASSERT_EQ(ARBITRARY_DOWN_TIME, event->getDownTime());
367
368 ASSERT_EQ(2U, event->getPointerCount());
369 ASSERT_EQ(1, event->getPointerId(0));
370 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, event->getToolType(0));
371 ASSERT_EQ(2, event->getPointerId(1));
372 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_STYLUS, event->getToolType(1));
373
374 ASSERT_EQ(2U, event->getHistorySize());
375
376 // Check data.
377 ASSERT_EQ(ARBITRARY_EVENT_TIME, event->getHistoricalEventTime(0));
378 ASSERT_EQ(ARBITRARY_EVENT_TIME + 1, event->getHistoricalEventTime(1));
379 ASSERT_EQ(ARBITRARY_EVENT_TIME + 2, event->getEventTime());
380
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700381 ASSERT_EQ(11, event->getHistoricalRawPointerCoords(0, 0)->getAxisValue(AMOTION_EVENT_AXIS_Y));
382 ASSERT_EQ(21, event->getHistoricalRawPointerCoords(1, 0)->getAxisValue(AMOTION_EVENT_AXIS_Y));
383 ASSERT_EQ(111, event->getHistoricalRawPointerCoords(0, 1)->getAxisValue(AMOTION_EVENT_AXIS_Y));
384 ASSERT_EQ(121, event->getHistoricalRawPointerCoords(1, 1)->getAxisValue(AMOTION_EVENT_AXIS_Y));
385 ASSERT_EQ(211, event->getRawPointerCoords(0)->getAxisValue(AMOTION_EVENT_AXIS_Y));
386 ASSERT_EQ(221, event->getRawPointerCoords(1)->getAxisValue(AMOTION_EVENT_AXIS_Y));
Jeff Brown5912f952013-07-01 19:10:31 -0700387
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700388 ASSERT_EQ(RAW_Y_OFFSET + 11 * RAW_Y_SCALE,
389 event->getHistoricalRawAxisValue(AMOTION_EVENT_AXIS_Y, 0, 0));
390 ASSERT_EQ(RAW_Y_OFFSET + 21 * RAW_Y_SCALE,
391 event->getHistoricalRawAxisValue(AMOTION_EVENT_AXIS_Y, 1, 0));
392 ASSERT_EQ(RAW_Y_OFFSET + 111 * RAW_Y_SCALE,
393 event->getHistoricalRawAxisValue(AMOTION_EVENT_AXIS_Y, 0, 1));
394 ASSERT_EQ(RAW_Y_OFFSET + 121 * RAW_Y_SCALE,
395 event->getHistoricalRawAxisValue(AMOTION_EVENT_AXIS_Y, 1, 1));
396 ASSERT_EQ(RAW_Y_OFFSET + 211 * RAW_Y_SCALE, event->getRawAxisValue(AMOTION_EVENT_AXIS_Y, 0));
397 ASSERT_EQ(RAW_Y_OFFSET + 221 * RAW_Y_SCALE, event->getRawAxisValue(AMOTION_EVENT_AXIS_Y, 1));
Jeff Brown5912f952013-07-01 19:10:31 -0700398
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700399 ASSERT_EQ(RAW_X_OFFSET + 10 * RAW_X_SCALE, event->getHistoricalRawX(0, 0));
400 ASSERT_EQ(RAW_X_OFFSET + 20 * RAW_X_SCALE, event->getHistoricalRawX(1, 0));
401 ASSERT_EQ(RAW_X_OFFSET + 110 * RAW_X_SCALE, event->getHistoricalRawX(0, 1));
402 ASSERT_EQ(RAW_X_OFFSET + 120 * RAW_X_SCALE, event->getHistoricalRawX(1, 1));
403 ASSERT_EQ(RAW_X_OFFSET + 210 * RAW_X_SCALE, event->getRawX(0));
404 ASSERT_EQ(RAW_X_OFFSET + 220 * RAW_X_SCALE, event->getRawX(1));
Jeff Brown5912f952013-07-01 19:10:31 -0700405
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700406 ASSERT_EQ(RAW_Y_OFFSET + 11 * RAW_Y_SCALE, event->getHistoricalRawY(0, 0));
407 ASSERT_EQ(RAW_Y_OFFSET + 21 * RAW_Y_SCALE, event->getHistoricalRawY(1, 0));
408 ASSERT_EQ(RAW_Y_OFFSET + 111 * RAW_Y_SCALE, event->getHistoricalRawY(0, 1));
409 ASSERT_EQ(RAW_Y_OFFSET + 121 * RAW_Y_SCALE, event->getHistoricalRawY(1, 1));
410 ASSERT_EQ(RAW_Y_OFFSET + 211 * RAW_Y_SCALE, event->getRawY(0));
411 ASSERT_EQ(RAW_Y_OFFSET + 221 * RAW_Y_SCALE, event->getRawY(1));
Jeff Brown5912f952013-07-01 19:10:31 -0700412
chaviw82357092020-01-28 13:13:06 -0800413 ASSERT_EQ(X_OFFSET + 10 * X_SCALE, event->getHistoricalX(0, 0));
414 ASSERT_EQ(X_OFFSET + 20 * X_SCALE, event->getHistoricalX(1, 0));
415 ASSERT_EQ(X_OFFSET + 110 * X_SCALE, event->getHistoricalX(0, 1));
416 ASSERT_EQ(X_OFFSET + 120 * X_SCALE, event->getHistoricalX(1, 1));
417 ASSERT_EQ(X_OFFSET + 210 * X_SCALE, event->getX(0));
418 ASSERT_EQ(X_OFFSET + 220 * X_SCALE, event->getX(1));
Jeff Brown5912f952013-07-01 19:10:31 -0700419
chaviw82357092020-01-28 13:13:06 -0800420 ASSERT_EQ(Y_OFFSET + 11 * Y_SCALE, event->getHistoricalY(0, 0));
421 ASSERT_EQ(Y_OFFSET + 21 * Y_SCALE, event->getHistoricalY(1, 0));
422 ASSERT_EQ(Y_OFFSET + 111 * Y_SCALE, event->getHistoricalY(0, 1));
423 ASSERT_EQ(Y_OFFSET + 121 * Y_SCALE, event->getHistoricalY(1, 1));
424 ASSERT_EQ(Y_OFFSET + 211 * Y_SCALE, event->getY(0));
425 ASSERT_EQ(Y_OFFSET + 221 * Y_SCALE, event->getY(1));
Jeff Brown5912f952013-07-01 19:10:31 -0700426
427 ASSERT_EQ(12, event->getHistoricalPressure(0, 0));
428 ASSERT_EQ(22, event->getHistoricalPressure(1, 0));
429 ASSERT_EQ(112, event->getHistoricalPressure(0, 1));
430 ASSERT_EQ(122, event->getHistoricalPressure(1, 1));
431 ASSERT_EQ(212, event->getPressure(0));
432 ASSERT_EQ(222, event->getPressure(1));
433
434 ASSERT_EQ(13, event->getHistoricalSize(0, 0));
435 ASSERT_EQ(23, event->getHistoricalSize(1, 0));
436 ASSERT_EQ(113, event->getHistoricalSize(0, 1));
437 ASSERT_EQ(123, event->getHistoricalSize(1, 1));
438 ASSERT_EQ(213, event->getSize(0));
439 ASSERT_EQ(223, event->getSize(1));
440
441 ASSERT_EQ(14, event->getHistoricalTouchMajor(0, 0));
442 ASSERT_EQ(24, event->getHistoricalTouchMajor(1, 0));
443 ASSERT_EQ(114, event->getHistoricalTouchMajor(0, 1));
444 ASSERT_EQ(124, event->getHistoricalTouchMajor(1, 1));
445 ASSERT_EQ(214, event->getTouchMajor(0));
446 ASSERT_EQ(224, event->getTouchMajor(1));
447
448 ASSERT_EQ(15, event->getHistoricalTouchMinor(0, 0));
449 ASSERT_EQ(25, event->getHistoricalTouchMinor(1, 0));
450 ASSERT_EQ(115, event->getHistoricalTouchMinor(0, 1));
451 ASSERT_EQ(125, event->getHistoricalTouchMinor(1, 1));
452 ASSERT_EQ(215, event->getTouchMinor(0));
453 ASSERT_EQ(225, event->getTouchMinor(1));
454
455 ASSERT_EQ(16, event->getHistoricalToolMajor(0, 0));
456 ASSERT_EQ(26, event->getHistoricalToolMajor(1, 0));
457 ASSERT_EQ(116, event->getHistoricalToolMajor(0, 1));
458 ASSERT_EQ(126, event->getHistoricalToolMajor(1, 1));
459 ASSERT_EQ(216, event->getToolMajor(0));
460 ASSERT_EQ(226, event->getToolMajor(1));
461
462 ASSERT_EQ(17, event->getHistoricalToolMinor(0, 0));
463 ASSERT_EQ(27, event->getHistoricalToolMinor(1, 0));
464 ASSERT_EQ(117, event->getHistoricalToolMinor(0, 1));
465 ASSERT_EQ(127, event->getHistoricalToolMinor(1, 1));
466 ASSERT_EQ(217, event->getToolMinor(0));
467 ASSERT_EQ(227, event->getToolMinor(1));
468
469 ASSERT_EQ(18, event->getHistoricalOrientation(0, 0));
470 ASSERT_EQ(28, event->getHistoricalOrientation(1, 0));
471 ASSERT_EQ(118, event->getHistoricalOrientation(0, 1));
472 ASSERT_EQ(128, event->getHistoricalOrientation(1, 1));
473 ASSERT_EQ(218, event->getOrientation(0));
474 ASSERT_EQ(228, event->getOrientation(1));
475}
476
477TEST_F(MotionEventTest, Properties) {
478 MotionEvent event;
479
480 // Initialize, add samples and check properties.
481 initializeEventWithHistory(&event);
482 ASSERT_NO_FATAL_FAILURE(assertEqualsEventWithHistory(&event));
483
484 // Set source.
485 event.setSource(AINPUT_SOURCE_JOYSTICK);
Siarhei Vishniakou3826d472020-01-27 10:44:40 -0600486 ASSERT_EQ(AINPUT_SOURCE_JOYSTICK, event.getSource());
Jeff Brown5912f952013-07-01 19:10:31 -0700487
Siarhei Vishniakou777a10b2018-01-31 16:45:06 -0800488 // Set displayId.
489 constexpr int32_t newDisplayId = 2;
490 event.setDisplayId(newDisplayId);
491 ASSERT_EQ(newDisplayId, event.getDisplayId());
492
Jeff Brown5912f952013-07-01 19:10:31 -0700493 // Set action.
494 event.setAction(AMOTION_EVENT_ACTION_CANCEL);
495 ASSERT_EQ(AMOTION_EVENT_ACTION_CANCEL, event.getAction());
496
497 // Set meta state.
498 event.setMetaState(AMETA_CTRL_ON);
499 ASSERT_EQ(AMETA_CTRL_ON, event.getMetaState());
500}
501
502TEST_F(MotionEventTest, CopyFrom_KeepHistory) {
503 MotionEvent event;
504 initializeEventWithHistory(&event);
505
506 MotionEvent copy;
507 copy.copyFrom(&event, true /*keepHistory*/);
508
509 ASSERT_NO_FATAL_FAILURE(assertEqualsEventWithHistory(&event));
510}
511
512TEST_F(MotionEventTest, CopyFrom_DoNotKeepHistory) {
513 MotionEvent event;
514 initializeEventWithHistory(&event);
515
516 MotionEvent copy;
517 copy.copyFrom(&event, false /*keepHistory*/);
518
519 ASSERT_EQ(event.getPointerCount(), copy.getPointerCount());
520 ASSERT_EQ(0U, copy.getHistorySize());
521
522 ASSERT_EQ(event.getPointerId(0), copy.getPointerId(0));
523 ASSERT_EQ(event.getPointerId(1), copy.getPointerId(1));
524
525 ASSERT_EQ(event.getEventTime(), copy.getEventTime());
526
527 ASSERT_EQ(event.getX(0), copy.getX(0));
528}
529
530TEST_F(MotionEventTest, OffsetLocation) {
531 MotionEvent event;
532 initializeEventWithHistory(&event);
533
534 event.offsetLocation(5.0f, -2.0f);
535
536 ASSERT_EQ(X_OFFSET + 5.0f, event.getXOffset());
537 ASSERT_EQ(Y_OFFSET - 2.0f, event.getYOffset());
538}
539
540TEST_F(MotionEventTest, Scale) {
541 MotionEvent event;
542 initializeEventWithHistory(&event);
543
544 event.scale(2.0f);
545
546 ASSERT_EQ(X_OFFSET * 2, event.getXOffset());
547 ASSERT_EQ(Y_OFFSET * 2, event.getYOffset());
548
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700549 ASSERT_EQ((RAW_X_OFFSET + 210 * RAW_X_SCALE) * 2, event.getRawX(0));
550 ASSERT_EQ((RAW_Y_OFFSET + 211 * RAW_Y_SCALE) * 2, event.getRawY(0));
chaviw82357092020-01-28 13:13:06 -0800551 ASSERT_EQ((X_OFFSET + 210 * X_SCALE) * 2, event.getX(0));
552 ASSERT_EQ((Y_OFFSET + 211 * Y_SCALE) * 2, event.getY(0));
Jeff Brown5912f952013-07-01 19:10:31 -0700553 ASSERT_EQ(212, event.getPressure(0));
554 ASSERT_EQ(213, event.getSize(0));
555 ASSERT_EQ(214 * 2, event.getTouchMajor(0));
556 ASSERT_EQ(215 * 2, event.getTouchMinor(0));
557 ASSERT_EQ(216 * 2, event.getToolMajor(0));
558 ASSERT_EQ(217 * 2, event.getToolMinor(0));
559 ASSERT_EQ(218, event.getOrientation(0));
560}
561
562TEST_F(MotionEventTest, Parcel) {
563 Parcel parcel;
564
565 MotionEvent inEvent;
566 initializeEventWithHistory(&inEvent);
567 MotionEvent outEvent;
568
569 // Round trip.
570 inEvent.writeToParcel(&parcel);
571 parcel.setDataPosition(0);
572 outEvent.readFromParcel(&parcel);
573
574 ASSERT_NO_FATAL_FAILURE(assertEqualsEventWithHistory(&outEvent));
575}
576
chaviw9eaa22c2020-07-01 16:21:27 -0700577static void setRotationMatrix(std::array<float, 9>& matrix, float angle) {
Jeff Brown313eff72013-07-15 18:07:09 -0700578 float sin = sinf(angle);
579 float cos = cosf(angle);
580 matrix[0] = cos;
581 matrix[1] = -sin;
582 matrix[2] = 0;
583 matrix[3] = sin;
584 matrix[4] = cos;
585 matrix[5] = 0;
586 matrix[6] = 0;
587 matrix[7] = 0;
588 matrix[8] = 1.0f;
589}
590
Jeff Brown5912f952013-07-01 19:10:31 -0700591TEST_F(MotionEventTest, Transform) {
592 // Generate some points on a circle.
593 // Each point 'i' is a point on a circle of radius ROTATION centered at (3,2) at an angle
594 // of ARC * i degrees clockwise relative to the Y axis.
595 // The geometrical representation is irrelevant to the test, it's just easy to generate
596 // and check rotation. We set the orientation to the same angle.
597 // Coordinate system: down is increasing Y, right is increasing X.
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700598 static constexpr float PI_180 = float(M_PI / 180);
599 static constexpr float RADIUS = 10;
600 static constexpr float ARC = 36;
601 static constexpr float ROTATION = ARC * 2;
Jeff Brown5912f952013-07-01 19:10:31 -0700602
603 const size_t pointerCount = 11;
604 PointerProperties pointerProperties[pointerCount];
605 PointerCoords pointerCoords[pointerCount];
606 for (size_t i = 0; i < pointerCount; i++) {
607 float angle = float(i * ARC * PI_180);
608 pointerProperties[i].clear();
609 pointerProperties[i].id = i;
610 pointerCoords[i].clear();
611 pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_X, sinf(angle) * RADIUS + 3);
612 pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_Y, -cosf(angle) * RADIUS + 2);
613 pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, angle);
614 }
615 MotionEvent event;
chaviw9eaa22c2020-07-01 16:21:27 -0700616 ui::Transform identityTransform;
Prabir Pradhan9f388812021-05-13 16:54:53 -0700617 event.initialize(InputEvent::nextId(), 0 /*deviceId*/, AINPUT_SOURCE_TOUCHSCREEN, DISPLAY_ID,
Garfield Tan4cc839f2020-01-24 11:26:14 -0800618 INVALID_HMAC, AMOTION_EVENT_ACTION_MOVE, 0 /*actionButton*/, 0 /*flags*/,
Siarhei Vishniakou9c858ac2020-01-23 14:20:11 -0600619 AMOTION_EVENT_EDGE_FLAG_NONE, AMETA_NONE, 0 /*buttonState*/,
chaviw9eaa22c2020-07-01 16:21:27 -0700620 MotionClassification::NONE, identityTransform, 0 /*xPrecision*/,
621 0 /*yPrecision*/, 3 + RADIUS /*xCursorPosition*/, 2 /*yCursorPosition*/,
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700622 identityTransform, 0 /*downTime*/, 0 /*eventTime*/, pointerCount,
623 pointerProperties, pointerCoords);
Jeff Brown5912f952013-07-01 19:10:31 -0700624 float originalRawX = 0 + 3;
625 float originalRawY = -RADIUS + 2;
626
627 // Check original raw X and Y assumption.
628 ASSERT_NEAR(originalRawX, event.getRawX(0), 0.001);
629 ASSERT_NEAR(originalRawY, event.getRawY(0), 0.001);
630
631 // Now translate the motion event so the circle's origin is at (0,0).
632 event.offsetLocation(-3, -2);
633
634 // Offsetting the location should preserve the raw X and Y of the first point.
635 ASSERT_NEAR(originalRawX, event.getRawX(0), 0.001);
636 ASSERT_NEAR(originalRawY, event.getRawY(0), 0.001);
637
638 // Apply a rotation about the origin by ROTATION degrees clockwise.
chaviw9eaa22c2020-07-01 16:21:27 -0700639 std::array<float, 9> matrix;
Jeff Brown313eff72013-07-15 18:07:09 -0700640 setRotationMatrix(matrix, ROTATION * PI_180);
641 event.transform(matrix);
Jeff Brown5912f952013-07-01 19:10:31 -0700642
643 // Check the points.
644 for (size_t i = 0; i < pointerCount; i++) {
645 float angle = float((i * ARC + ROTATION) * PI_180);
646 ASSERT_NEAR(sinf(angle) * RADIUS, event.getX(i), 0.001);
647 ASSERT_NEAR(-cosf(angle) * RADIUS, event.getY(i), 0.001);
648 ASSERT_NEAR(tanf(angle), tanf(event.getOrientation(i)), 0.1);
649 }
650
Garfield Tanab0ab9c2019-07-10 18:58:28 -0700651 // Check cursor positions. The original cursor position is at (3 + RADIUS, 2), where the center
652 // of the circle is (3, 2), so the cursor position is to the right of the center of the circle.
653 // The choice of triangular functions in this test defines the angle of rotation clockwise
654 // relative to the y-axis. Therefore the cursor position's angle is 90 degrees. Here we swap the
655 // triangular function so that we don't have to add the 90 degrees.
656 ASSERT_NEAR(cosf(PI_180 * ROTATION) * RADIUS, event.getXCursorPosition(), 0.001);
657 ASSERT_NEAR(sinf(PI_180 * ROTATION) * RADIUS, event.getYCursorPosition(), 0.001);
Garfield Tan00f511d2019-06-12 16:55:40 -0700658
Jeff Brown5912f952013-07-01 19:10:31 -0700659 // Applying the transformation should preserve the raw X and Y of the first point.
660 ASSERT_NEAR(originalRawX, event.getRawX(0), 0.001);
661 ASSERT_NEAR(originalRawY, event.getRawY(0), 0.001);
662}
663
Prabir Pradhanc6523582021-05-14 18:02:55 -0700664MotionEvent createTouchDownEvent(float x, float y, float dx, float dy,
Evan Rosky09576692021-07-01 12:22:09 -0700665 const ui::Transform& transform,
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700666 const ui::Transform& rawTransform) {
Evan Roskyd4d4d802021-05-03 20:12:21 -0700667 std::vector<PointerProperties> pointerProperties;
668 pointerProperties.push_back(PointerProperties{/* id */ 0, AMOTION_EVENT_TOOL_TYPE_FINGER});
669 std::vector<PointerCoords> pointerCoords;
670 pointerCoords.emplace_back().clear();
671 pointerCoords.back().setAxisValue(AMOTION_EVENT_AXIS_X, x);
672 pointerCoords.back().setAxisValue(AMOTION_EVENT_AXIS_Y, y);
Prabir Pradhanc6523582021-05-14 18:02:55 -0700673 pointerCoords.back().setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, dx);
674 pointerCoords.back().setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, dy);
Evan Roskyd4d4d802021-05-03 20:12:21 -0700675 nsecs_t eventTime = systemTime(SYSTEM_TIME_MONOTONIC);
676 MotionEvent event;
677 event.initialize(InputEvent::nextId(), /* deviceId */ 1, AINPUT_SOURCE_TOUCHSCREEN,
678 /* displayId */ 0, INVALID_HMAC, AMOTION_EVENT_ACTION_DOWN,
679 /* actionButton */ 0, /* flags */ 0, /* edgeFlags */ 0, AMETA_NONE,
680 /* buttonState */ 0, MotionClassification::NONE, transform,
681 /* xPrecision */ 0, /* yPrecision */ 0, AMOTION_EVENT_INVALID_CURSOR_POSITION,
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700682 AMOTION_EVENT_INVALID_CURSOR_POSITION, rawTransform, eventTime, eventTime,
683 pointerCoords.size(), pointerProperties.data(), pointerCoords.data());
Evan Roskyd4d4d802021-05-03 20:12:21 -0700684 return event;
685}
Evan Rosky84f07f02021-04-16 10:42:42 -0700686
Evan Roskyd4d4d802021-05-03 20:12:21 -0700687TEST_F(MotionEventTest, ApplyTransform) {
688 // Create a rotate-90 transform with an offset (like a window which isn't fullscreen).
689 ui::Transform identity;
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700690 ui::Transform transform(ui::Transform::ROT_90, 800, 400);
691 transform.set(transform.tx() + 20, transform.ty() + 40);
692 ui::Transform rawTransform(ui::Transform::ROT_90, 800, 400);
693 MotionEvent event = createTouchDownEvent(60, 100, 42, 96, transform, rawTransform);
Evan Roskyd4d4d802021-05-03 20:12:21 -0700694 ASSERT_EQ(700, event.getRawX(0));
695 ASSERT_EQ(60, event.getRawY(0));
696 ASSERT_NE(event.getRawX(0), event.getX(0));
697 ASSERT_NE(event.getRawY(0), event.getY(0));
Prabir Pradhanc6523582021-05-14 18:02:55 -0700698 // Relative values should be rotated but not translated.
699 ASSERT_EQ(-96, event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, 0));
700 ASSERT_EQ(42, event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, 0));
Evan Roskyd4d4d802021-05-03 20:12:21 -0700701
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700702 MotionEvent changedEvent = createTouchDownEvent(60, 100, 42, 96, identity, identity);
703 const std::array<float, 9> rowMajor{transform[0][0], transform[1][0], transform[2][0],
704 transform[0][1], transform[1][1], transform[2][1],
705 transform[0][2], transform[1][2], transform[2][2]};
Evan Roskyd4d4d802021-05-03 20:12:21 -0700706 changedEvent.applyTransform(rowMajor);
707
708 // transformContent effectively rotates the raw coordinates, so those should now include
Prabir Pradhanc6523582021-05-14 18:02:55 -0700709 // both rotation AND offset.
Evan Roskyd4d4d802021-05-03 20:12:21 -0700710 ASSERT_EQ(720, changedEvent.getRawX(0));
711 ASSERT_EQ(100, changedEvent.getRawY(0));
Prabir Pradhanc6523582021-05-14 18:02:55 -0700712 // Relative values should be rotated but not translated.
713 ASSERT_EQ(-96, event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, 0));
714 ASSERT_EQ(42, event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, 0));
Evan Roskyd4d4d802021-05-03 20:12:21 -0700715
Prabir Pradhanc6523582021-05-14 18:02:55 -0700716 // The transformed output should be the same then.
Evan Roskyd4d4d802021-05-03 20:12:21 -0700717 ASSERT_NEAR(event.getX(0), changedEvent.getX(0), 0.001);
718 ASSERT_NEAR(event.getY(0), changedEvent.getY(0), 0.001);
Prabir Pradhanc6523582021-05-14 18:02:55 -0700719 ASSERT_NEAR(event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, 0),
720 changedEvent.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, 0), 0.001);
721 ASSERT_NEAR(event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, 0),
722 changedEvent.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, 0), 0.001);
Evan Roskyd4d4d802021-05-03 20:12:21 -0700723}
724
Prabir Pradhan9f388812021-05-13 16:54:53 -0700725TEST_F(MotionEventTest, NonPointerSourcesAreNotTranslated) {
726 constexpr static auto NON_POINTER_SOURCES = {AINPUT_SOURCE_TRACKBALL,
727 AINPUT_SOURCE_MOUSE_RELATIVE,
728 AINPUT_SOURCE_JOYSTICK};
729 for (uint32_t source : NON_POINTER_SOURCES) {
730 // Create a rotate-90 transform with an offset (like a window which isn't fullscreen).
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700731 ui::Transform transform(ui::Transform::ROT_90, 800, 400);
732 transform.set(transform.tx() + 20, transform.ty() + 40);
733 MotionEvent event = createTouchDownEvent(60, 100, 42, 96, transform, transform);
Prabir Pradhan9f388812021-05-13 16:54:53 -0700734 event.setSource(source);
735
736 // Since this event comes from a non-pointer source, it should include rotation but not
737 // translation/offset.
738 ASSERT_EQ(-100, event.getX(0));
739 ASSERT_EQ(60, event.getY(0));
740 ASSERT_EQ(event.getRawX(0), event.getX(0));
741 ASSERT_EQ(event.getRawY(0), event.getY(0));
742 }
743}
744
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700745TEST_F(MotionEventTest, AxesAreCorrectlyTransformed) {
746 const ui::Transform identity;
747 ui::Transform transform;
748 transform.set({1.1, -2.2, 3.3, -4.4, 5.5, -6.6, 0, 0, 1});
749 ui::Transform rawTransform;
750 rawTransform.set({-6.6, 5.5, -4.4, 3.3, -2.2, 1.1, 0, 0, 1});
751 auto transformWithoutTranslation = [](const ui::Transform& t, float x, float y) {
752 auto newPoint = t.transform(x, y);
753 auto newOrigin = t.transform(0, 0);
754 return newPoint - newOrigin;
755 };
Evan Rosky84f07f02021-04-16 10:42:42 -0700756
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700757 const MotionEvent event = createTouchDownEvent(60, 100, 42, 96, transform, rawTransform);
Evan Rosky84f07f02021-04-16 10:42:42 -0700758
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700759 // The x and y axes should have the window transform applied.
760 const auto newPoint = transform.transform(60, 100);
761 ASSERT_EQ(newPoint.x, event.getX(0));
762 ASSERT_EQ(newPoint.y, event.getY(0));
Evan Rosky84f07f02021-04-16 10:42:42 -0700763
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700764 // The raw values should have the display transform applied.
765 const auto raw = rawTransform.transform(60, 100);
766 ASSERT_EQ(raw.x, event.getRawX(0));
767 ASSERT_EQ(raw.y, event.getRawY(0));
Evan Rosky09576692021-07-01 12:22:09 -0700768
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700769 // Relative values should have the window transform applied without any translation.
770 const auto rel = transformWithoutTranslation(transform, 42, 96);
771 ASSERT_EQ(rel.x, event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, 0));
772 ASSERT_EQ(rel.y, event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, 0));
Evan Rosky84f07f02021-04-16 10:42:42 -0700773}
774
Siarhei Vishniakou16a2e302019-01-14 19:21:45 -0800775TEST_F(MotionEventTest, Initialize_SetsClassification) {
776 std::array<MotionClassification, 3> classifications = {
777 MotionClassification::NONE,
778 MotionClassification::AMBIGUOUS_GESTURE,
779 MotionClassification::DEEP_PRESS,
780 };
781
782 MotionEvent event;
783 constexpr size_t pointerCount = 1;
784 PointerProperties pointerProperties[pointerCount];
785 PointerCoords pointerCoords[pointerCount];
786 for (size_t i = 0; i < pointerCount; i++) {
787 pointerProperties[i].clear();
788 pointerProperties[i].id = i;
789 pointerCoords[i].clear();
790 }
791
chaviw9eaa22c2020-07-01 16:21:27 -0700792 ui::Transform identityTransform;
Siarhei Vishniakou16a2e302019-01-14 19:21:45 -0800793 for (MotionClassification classification : classifications) {
Garfield Tan4cc839f2020-01-24 11:26:14 -0800794 event.initialize(InputEvent::nextId(), 0 /*deviceId*/, AINPUT_SOURCE_TOUCHSCREEN,
795 DISPLAY_ID, INVALID_HMAC, AMOTION_EVENT_ACTION_DOWN, 0, 0,
chaviw9eaa22c2020-07-01 16:21:27 -0700796 AMOTION_EVENT_EDGE_FLAG_NONE, AMETA_NONE, 0, classification,
797 identityTransform, 0, 0, AMOTION_EVENT_INVALID_CURSOR_POSITION,
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700798 AMOTION_EVENT_INVALID_CURSOR_POSITION, identityTransform, 0 /*downTime*/,
Evan Rosky09576692021-07-01 12:22:09 -0700799 0 /*eventTime*/, pointerCount, pointerProperties, pointerCoords);
Siarhei Vishniakou16a2e302019-01-14 19:21:45 -0800800 ASSERT_EQ(classification, event.getClassification());
801 }
802}
803
Garfield Tan00f511d2019-06-12 16:55:40 -0700804TEST_F(MotionEventTest, Initialize_SetsCursorPosition) {
805 MotionEvent event;
806 constexpr size_t pointerCount = 1;
807 PointerProperties pointerProperties[pointerCount];
808 PointerCoords pointerCoords[pointerCount];
809 for (size_t i = 0; i < pointerCount; i++) {
810 pointerProperties[i].clear();
811 pointerProperties[i].id = i;
812 pointerCoords[i].clear();
813 }
814
chaviw9eaa22c2020-07-01 16:21:27 -0700815 ui::Transform identityTransform;
Garfield Tan4cc839f2020-01-24 11:26:14 -0800816 event.initialize(InputEvent::nextId(), 0 /*deviceId*/, AINPUT_SOURCE_MOUSE, DISPLAY_ID,
817 INVALID_HMAC, AMOTION_EVENT_ACTION_DOWN, 0, 0, AMOTION_EVENT_EDGE_FLAG_NONE,
chaviw9eaa22c2020-07-01 16:21:27 -0700818 AMETA_NONE, 0, MotionClassification::NONE, identityTransform, 0, 0,
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700819 280 /*xCursorPosition*/, 540 /*yCursorPosition*/, identityTransform,
820 0 /*downTime*/, 0 /*eventTime*/, pointerCount, pointerProperties,
821 pointerCoords);
Garfield Tan00f511d2019-06-12 16:55:40 -0700822 event.offsetLocation(20, 60);
823 ASSERT_EQ(280, event.getRawXCursorPosition());
824 ASSERT_EQ(540, event.getRawYCursorPosition());
825 ASSERT_EQ(300, event.getXCursorPosition());
826 ASSERT_EQ(600, event.getYCursorPosition());
827}
828
Garfield Tan937bb832019-07-25 17:48:31 -0700829TEST_F(MotionEventTest, SetCursorPosition) {
830 MotionEvent event;
831 initializeEventWithHistory(&event);
832 event.setSource(AINPUT_SOURCE_MOUSE);
833
834 event.setCursorPosition(3, 4);
835 ASSERT_EQ(3, event.getXCursorPosition());
836 ASSERT_EQ(4, event.getYCursorPosition());
837}
838
Jeff Brown5912f952013-07-01 19:10:31 -0700839} // namespace android