xref: /aosp_15_r20/frameworks/native/libs/input/tests/InputEvent_test.cpp (revision 38e8c45f13ce32b0dcecb25141ffecaf386fa17f) 
1 /*
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 
17 #include <array>
18 #include <math.h>
19 
20 #include <android-base/properties.h>
21 #include <attestation/HmacKeyManager.h>
22 #include <binder/Parcel.h>
23 #include <gtest/gtest.h>
24 #include <input/Input.h>
25 #include <input/InputEventBuilders.h>
26 
27 namespace android {
28 
29 namespace {
30 
31 // Default display id.
32 constexpr ui::LogicalDisplayId DISPLAY_ID = ui::LogicalDisplayId::DEFAULT;
33 
34 constexpr float EPSILON = MotionEvent::ROUNDING_PRECISION;
35 
36 constexpr auto POINTER_0_DOWN =
37         AMOTION_EVENT_ACTION_POINTER_DOWN | (0 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
38 
39 constexpr auto POINTER_1_DOWN =
40         AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
41 
42 constexpr auto POINTER_0_UP =
43         AMOTION_EVENT_ACTION_POINTER_UP | (0 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
44 
45 constexpr auto POINTER_1_UP =
46         AMOTION_EVENT_ACTION_POINTER_UP | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
47 
asFloat9(const ui::Transform & t)48 std::array<float, 9> asFloat9(const ui::Transform& t) {
49     std::array<float, 9> mat{};
50     mat[0] = t[0][0];
51     mat[1] = t[1][0];
52     mat[2] = t[2][0];
53     mat[3] = t[0][1];
54     mat[4] = t[1][1];
55     mat[5] = t[2][1];
56     mat[6] = t[0][2];
57     mat[7] = t[1][2];
58     mat[8] = t[2][2];
59     return mat;
60 }
61 
62 class BaseTest : public testing::Test {
63 protected:
64     static constexpr std::array<uint8_t, 32> HMAC = {0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10,
65                                                      11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
66                                                      22, 23, 24, 25, 26, 27, 28, 29, 30, 31};
67 };
68 
69 } // namespace
70 
71 // --- PointerCoordsTest ---
72 
73 class PointerCoordsTest : public BaseTest {
74 };
75 
TEST_F(PointerCoordsTest,ClearSetsBitsToZero)76 TEST_F(PointerCoordsTest, ClearSetsBitsToZero) {
77     PointerCoords coords;
78     coords.clear();
79 
80     ASSERT_EQ(0ULL, coords.bits);
81     ASSERT_FALSE(coords.isResampled);
82 }
83 
TEST_F(PointerCoordsTest,AxisValues)84 TEST_F(PointerCoordsTest, AxisValues) {
85     PointerCoords coords;
86     coords.clear();
87 
88     // Check invariants when no axes are present.
89     ASSERT_EQ(0, coords.getAxisValue(0))
90             << "getAxisValue should return zero because axis is not present";
91     ASSERT_EQ(0, coords.getAxisValue(1))
92             << "getAxisValue should return zero because axis is not present";
93 
94     // Set first axis.
95     ASSERT_EQ(OK, coords.setAxisValue(1, 5));
96     ASSERT_EQ(5, coords.values[0]);
97     ASSERT_EQ(0x4000000000000000ULL, coords.bits);
98 
99     ASSERT_EQ(0, coords.getAxisValue(0))
100             << "getAxisValue should return zero because axis is not present";
101     ASSERT_EQ(5, coords.getAxisValue(1))
102             << "getAxisValue should return value of axis";
103 
104     // Set an axis with a higher id than all others.  (appending value at the end)
105     ASSERT_EQ(OK, coords.setAxisValue(3, 2));
106     ASSERT_EQ(0x5000000000000000ULL, coords.bits);
107     ASSERT_EQ(5, coords.values[0]);
108     ASSERT_EQ(2, coords.values[1]);
109 
110     ASSERT_EQ(0, coords.getAxisValue(0))
111             << "getAxisValue should return zero because axis is not present";
112     ASSERT_EQ(5, coords.getAxisValue(1))
113             << "getAxisValue should return value of axis";
114     ASSERT_EQ(0, coords.getAxisValue(2))
115             << "getAxisValue should return zero because axis is not present";
116     ASSERT_EQ(2, coords.getAxisValue(3))
117             << "getAxisValue should return value of axis";
118 
119     // Set an axis with an id lower than all others.  (prepending value at beginning)
120     ASSERT_EQ(OK, coords.setAxisValue(0, 4));
121     ASSERT_EQ(0xd000000000000000ULL, coords.bits);
122     ASSERT_EQ(4, coords.values[0]);
123     ASSERT_EQ(5, coords.values[1]);
124     ASSERT_EQ(2, coords.values[2]);
125 
126     ASSERT_EQ(4, coords.getAxisValue(0))
127             << "getAxisValue should return value of axis";
128     ASSERT_EQ(5, coords.getAxisValue(1))
129             << "getAxisValue should return value of axis";
130     ASSERT_EQ(0, coords.getAxisValue(2))
131             << "getAxisValue should return zero because axis is not present";
132     ASSERT_EQ(2, coords.getAxisValue(3))
133             << "getAxisValue should return value of axis";
134 
135     // Set an axis with an id between the others.  (inserting value in the middle)
136     ASSERT_EQ(OK, coords.setAxisValue(2, 1));
137     ASSERT_EQ(0xf000000000000000ULL, coords.bits);
138     ASSERT_EQ(4, coords.values[0]);
139     ASSERT_EQ(5, coords.values[1]);
140     ASSERT_EQ(1, coords.values[2]);
141     ASSERT_EQ(2, coords.values[3]);
142 
143     ASSERT_EQ(4, coords.getAxisValue(0))
144             << "getAxisValue should return value of axis";
145     ASSERT_EQ(5, coords.getAxisValue(1))
146             << "getAxisValue should return value of axis";
147     ASSERT_EQ(1, coords.getAxisValue(2))
148             << "getAxisValue should return value of axis";
149     ASSERT_EQ(2, coords.getAxisValue(3))
150             << "getAxisValue should return value of axis";
151 
152     // Set an existing axis value in place.
153     ASSERT_EQ(OK, coords.setAxisValue(1, 6));
154     ASSERT_EQ(0xf000000000000000ULL, coords.bits);
155     ASSERT_EQ(4, coords.values[0]);
156     ASSERT_EQ(6, coords.values[1]);
157     ASSERT_EQ(1, coords.values[2]);
158     ASSERT_EQ(2, coords.values[3]);
159 
160     ASSERT_EQ(4, coords.getAxisValue(0))
161             << "getAxisValue should return value of axis";
162     ASSERT_EQ(6, coords.getAxisValue(1))
163             << "getAxisValue should return value of axis";
164     ASSERT_EQ(1, coords.getAxisValue(2))
165             << "getAxisValue should return value of axis";
166     ASSERT_EQ(2, coords.getAxisValue(3))
167             << "getAxisValue should return value of axis";
168 
169     // Set maximum number of axes.
170     for (size_t axis = 4; axis < PointerCoords::MAX_AXES; axis++) {
171         ASSERT_EQ(OK, coords.setAxisValue(axis, axis));
172     }
173     ASSERT_EQ(PointerCoords::MAX_AXES, __builtin_popcountll(coords.bits));
174 
175     // Try to set one more axis beyond maximum number.
176     // Ensure bits are unchanged.
177     ASSERT_EQ(NO_MEMORY, coords.setAxisValue(PointerCoords::MAX_AXES, 100));
178     ASSERT_EQ(PointerCoords::MAX_AXES, __builtin_popcountll(coords.bits));
179 }
180 
TEST_F(PointerCoordsTest,Parcel)181 TEST_F(PointerCoordsTest, Parcel) {
182     Parcel parcel;
183 
184     PointerCoords inCoords;
185     inCoords.clear();
186     PointerCoords outCoords;
187 
188     // Round trip with empty coords.
189     inCoords.writeToParcel(&parcel);
190     parcel.setDataPosition(0);
191     outCoords.readFromParcel(&parcel);
192 
193     ASSERT_EQ(0ULL, outCoords.bits);
194     ASSERT_FALSE(outCoords.isResampled);
195 
196     // Round trip with some values.
197     parcel.freeData();
198     inCoords.setAxisValue(2, 5);
199     inCoords.setAxisValue(5, 8);
200     inCoords.isResampled = true;
201 
202     inCoords.writeToParcel(&parcel);
203     parcel.setDataPosition(0);
204     outCoords.readFromParcel(&parcel);
205 
206     ASSERT_EQ(outCoords.bits, inCoords.bits);
207     ASSERT_EQ(outCoords.values[0], inCoords.values[0]);
208     ASSERT_EQ(outCoords.values[1], inCoords.values[1]);
209     ASSERT_TRUE(outCoords.isResampled);
210 }
211 
212 
213 // --- KeyEventTest ---
214 
215 class KeyEventTest : public BaseTest {
216 };
217 
TEST_F(KeyEventTest,Properties)218 TEST_F(KeyEventTest, Properties) {
219     KeyEvent event;
220 
221     // Initialize and get properties.
222     constexpr nsecs_t ARBITRARY_DOWN_TIME = 1;
223     constexpr nsecs_t ARBITRARY_EVENT_TIME = 2;
224     const int32_t id = InputEvent::nextId();
225     event.initialize(id, 2, AINPUT_SOURCE_GAMEPAD, DISPLAY_ID, HMAC, AKEY_EVENT_ACTION_DOWN,
226                      AKEY_EVENT_FLAG_FROM_SYSTEM, AKEYCODE_BUTTON_X, 121, AMETA_ALT_ON, 1,
227                      ARBITRARY_DOWN_TIME, ARBITRARY_EVENT_TIME);
228 
229     ASSERT_EQ(id, event.getId());
230     ASSERT_EQ(InputEventType::KEY, event.getType());
231     ASSERT_EQ(2, event.getDeviceId());
232     ASSERT_EQ(AINPUT_SOURCE_GAMEPAD, event.getSource());
233     ASSERT_EQ(DISPLAY_ID, event.getDisplayId());
234     EXPECT_EQ(HMAC, event.getHmac());
235     ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, event.getAction());
236     ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, event.getFlags());
237     ASSERT_EQ(AKEYCODE_BUTTON_X, event.getKeyCode());
238     ASSERT_EQ(121, event.getScanCode());
239     ASSERT_EQ(AMETA_ALT_ON, event.getMetaState());
240     ASSERT_EQ(1, event.getRepeatCount());
241     ASSERT_EQ(ARBITRARY_DOWN_TIME, event.getDownTime());
242     ASSERT_EQ(ARBITRARY_EVENT_TIME, event.getEventTime());
243 
244     // Set source.
245     event.setSource(AINPUT_SOURCE_JOYSTICK);
246     ASSERT_EQ(AINPUT_SOURCE_JOYSTICK, event.getSource());
247 
248     // Set display id.
249     constexpr ui::LogicalDisplayId newDisplayId = ui::LogicalDisplayId{2};
250     event.setDisplayId(newDisplayId);
251     ASSERT_EQ(newDisplayId, event.getDisplayId());
252 }
253 
254 
255 // --- MotionEventTest ---
256 
257 class MotionEventTest : public BaseTest {
258 protected:
259     static constexpr nsecs_t ARBITRARY_DOWN_TIME = 1;
260     static constexpr nsecs_t ARBITRARY_EVENT_TIME = 2;
261     static constexpr float X_SCALE = 2.0;
262     static constexpr float Y_SCALE = 3.0;
263     static constexpr float X_OFFSET = 1;
264     static constexpr float Y_OFFSET = 1.1;
265     static constexpr float RAW_X_SCALE = 4.0;
266     static constexpr float RAW_Y_SCALE = -5.0;
267     static constexpr float RAW_X_OFFSET = 12;
268     static constexpr float RAW_Y_OFFSET = -41.1;
269 
270     void SetUp() override;
271 
272     int32_t mId;
273     ui::Transform mTransform;
274     ui::Transform mRawTransform;
275     PointerProperties mPointerProperties[2];
276     struct Sample {
277         PointerCoords pointerCoords[2];
278     };
279     std::array<Sample, 3> mSamples{};
280 
281     void initializeEventWithHistory(MotionEvent* event);
282     void assertEqualsEventWithHistory(const MotionEvent* event);
283 };
284 
SetUp()285 void MotionEventTest::SetUp() {
286     mId = InputEvent::nextId();
287     mTransform.set({X_SCALE, 0, X_OFFSET, 0, Y_SCALE, Y_OFFSET, 0, 0, 1});
288     mRawTransform.set({RAW_X_SCALE, 0, RAW_X_OFFSET, 0, RAW_Y_SCALE, RAW_Y_OFFSET, 0, 0, 1});
289 
290     mPointerProperties[0].clear();
291     mPointerProperties[0].id = 1;
292     mPointerProperties[0].toolType = ToolType::FINGER;
293     mPointerProperties[1].clear();
294     mPointerProperties[1].id = 2;
295     mPointerProperties[1].toolType = ToolType::STYLUS;
296 
297     mSamples[0].pointerCoords[0].clear();
298     mSamples[0].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X, 10);
299     mSamples[0].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, 11);
300     mSamples[0].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 12);
301     mSamples[0].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 13);
302     mSamples[0].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 14);
303     mSamples[0].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 15);
304     mSamples[0].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 16);
305     mSamples[0].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 17);
306     mSamples[0].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 18);
307     mSamples[0].pointerCoords[0].isResampled = true;
308     mSamples[0].pointerCoords[1].clear();
309     mSamples[0].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_X, 20);
310     mSamples[0].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_Y, 21);
311     mSamples[0].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 22);
312     mSamples[0].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 23);
313     mSamples[0].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 24);
314     mSamples[0].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 25);
315     mSamples[0].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 26);
316     mSamples[0].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 27);
317     mSamples[0].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 28);
318 
319     mSamples[1].pointerCoords[0].clear();
320     mSamples[1].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X, 110);
321     mSamples[1].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, 111);
322     mSamples[1].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 112);
323     mSamples[1].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 113);
324     mSamples[1].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 114);
325     mSamples[1].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 115);
326     mSamples[1].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 116);
327     mSamples[1].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 117);
328     mSamples[1].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 118);
329     mSamples[1].pointerCoords[0].isResampled = true;
330     mSamples[1].pointerCoords[1].clear();
331     mSamples[1].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_X, 120);
332     mSamples[1].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_Y, 121);
333     mSamples[1].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 122);
334     mSamples[1].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 123);
335     mSamples[1].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 124);
336     mSamples[1].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 125);
337     mSamples[1].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 126);
338     mSamples[1].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 127);
339     mSamples[1].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 128);
340     mSamples[1].pointerCoords[1].isResampled = true;
341 
342     mSamples[2].pointerCoords[0].clear();
343     mSamples[2].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X, 210);
344     mSamples[2].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, 211);
345     mSamples[2].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 212);
346     mSamples[2].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 213);
347     mSamples[2].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 214);
348     mSamples[2].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 215);
349     mSamples[2].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 216);
350     mSamples[2].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 217);
351     mSamples[2].pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 218);
352     mSamples[2].pointerCoords[1].clear();
353     mSamples[2].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_X, 220);
354     mSamples[2].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_Y, 221);
355     mSamples[2].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 222);
356     mSamples[2].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 223);
357     mSamples[2].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 224);
358     mSamples[2].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 225);
359     mSamples[2].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 226);
360     mSamples[2].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 227);
361     mSamples[2].pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 228);
362 }
363 
initializeEventWithHistory(MotionEvent * event)364 void MotionEventTest::initializeEventWithHistory(MotionEvent* event) {
365     const int32_t flags = AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED |
366             AMOTION_EVENT_PRIVATE_FLAG_SUPPORTS_ORIENTATION |
367             AMOTION_EVENT_PRIVATE_FLAG_SUPPORTS_DIRECTIONAL_ORIENTATION;
368     event->initialize(mId, 2, AINPUT_SOURCE_TOUCHSCREEN, DISPLAY_ID, HMAC,
369                       AMOTION_EVENT_ACTION_MOVE, 0, flags, AMOTION_EVENT_EDGE_FLAG_TOP,
370                       AMETA_ALT_ON, AMOTION_EVENT_BUTTON_PRIMARY, MotionClassification::NONE,
371                       mTransform, 2.0f, 2.1f, AMOTION_EVENT_INVALID_CURSOR_POSITION,
372                       AMOTION_EVENT_INVALID_CURSOR_POSITION, mRawTransform, ARBITRARY_DOWN_TIME,
373                       ARBITRARY_EVENT_TIME, 2, mPointerProperties, mSamples[0].pointerCoords);
374     event->addSample(ARBITRARY_EVENT_TIME + 1, mSamples[1].pointerCoords, event->getId());
375     event->addSample(ARBITRARY_EVENT_TIME + 2, mSamples[2].pointerCoords, event->getId());
376 }
377 
assertEqualsEventWithHistory(const MotionEvent * event)378 void MotionEventTest::assertEqualsEventWithHistory(const MotionEvent* event) {
379     // Check properties.
380     ASSERT_EQ(mId, event->getId());
381     ASSERT_EQ(InputEventType::MOTION, event->getType());
382     ASSERT_EQ(2, event->getDeviceId());
383     ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, event->getSource());
384     ASSERT_EQ(DISPLAY_ID, event->getDisplayId());
385     EXPECT_EQ(HMAC, event->getHmac());
386     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, event->getAction());
387     ASSERT_EQ(AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED |
388                       AMOTION_EVENT_PRIVATE_FLAG_SUPPORTS_ORIENTATION |
389                       AMOTION_EVENT_PRIVATE_FLAG_SUPPORTS_DIRECTIONAL_ORIENTATION,
390               event->getFlags());
391     ASSERT_EQ(AMOTION_EVENT_EDGE_FLAG_TOP, event->getEdgeFlags());
392     ASSERT_EQ(AMETA_ALT_ON, event->getMetaState());
393     ASSERT_EQ(AMOTION_EVENT_BUTTON_PRIMARY, event->getButtonState());
394     ASSERT_EQ(MotionClassification::NONE, event->getClassification());
395     EXPECT_EQ(mTransform, event->getTransform());
396     ASSERT_NEAR((-RAW_X_OFFSET / RAW_X_SCALE) * X_SCALE + X_OFFSET, event->getRawXOffset(),
397                 EPSILON);
398     ASSERT_NEAR((-RAW_Y_OFFSET / RAW_Y_SCALE) * Y_SCALE + Y_OFFSET, event->getRawYOffset(),
399                 EPSILON);
400     ASSERT_EQ(2.0f, event->getXPrecision());
401     ASSERT_EQ(2.1f, event->getYPrecision());
402     ASSERT_EQ(ARBITRARY_DOWN_TIME, event->getDownTime());
403 
404     ASSERT_EQ(2U, event->getPointerCount());
405     ASSERT_EQ(1, event->getPointerId(0));
406     ASSERT_EQ(ToolType::FINGER, event->getToolType(0));
407     ASSERT_EQ(2, event->getPointerId(1));
408     ASSERT_EQ(ToolType::STYLUS, event->getToolType(1));
409 
410     ASSERT_EQ(2U, event->getHistorySize());
411 
412     // Check data.
413     ASSERT_EQ(ARBITRARY_EVENT_TIME, event->getHistoricalEventTime(0));
414     ASSERT_EQ(ARBITRARY_EVENT_TIME + 1, event->getHistoricalEventTime(1));
415     ASSERT_EQ(ARBITRARY_EVENT_TIME + 2, event->getEventTime());
416 
417     // Ensure the underlying PointerCoords are identical.
418     for (int sampleIdx = 0; sampleIdx < 3; sampleIdx++) {
419         for (int pointerIdx = 0; pointerIdx < 2; pointerIdx++) {
420             ASSERT_EQ(mSamples[sampleIdx].pointerCoords[pointerIdx],
421                       event->getSamplePointerCoords()[sampleIdx * 2 + pointerIdx]);
422         }
423     }
424 
425     ASSERT_NEAR(11, event->getHistoricalRawPointerCoords(0, 0)->getAxisValue(AMOTION_EVENT_AXIS_Y),
426                 EPSILON);
427     ASSERT_NEAR(21, event->getHistoricalRawPointerCoords(1, 0)->getAxisValue(AMOTION_EVENT_AXIS_Y),
428                 EPSILON);
429     ASSERT_NEAR(111, event->getHistoricalRawPointerCoords(0, 1)->getAxisValue(AMOTION_EVENT_AXIS_Y),
430                 EPSILON);
431     ASSERT_NEAR(121, event->getHistoricalRawPointerCoords(1, 1)->getAxisValue(AMOTION_EVENT_AXIS_Y),
432                 EPSILON);
433     ASSERT_NEAR(211, event->getRawPointerCoords(0)->getAxisValue(AMOTION_EVENT_AXIS_Y), EPSILON);
434     ASSERT_NEAR(221, event->getRawPointerCoords(1)->getAxisValue(AMOTION_EVENT_AXIS_Y), EPSILON);
435 
436     ASSERT_NEAR(RAW_Y_OFFSET + 11 * RAW_Y_SCALE,
437                 event->getHistoricalRawAxisValue(AMOTION_EVENT_AXIS_Y, 0, 0), EPSILON);
438     ASSERT_NEAR(RAW_Y_OFFSET + 21 * RAW_Y_SCALE,
439                 event->getHistoricalRawAxisValue(AMOTION_EVENT_AXIS_Y, 1, 0), EPSILON);
440     ASSERT_NEAR(RAW_Y_OFFSET + 111 * RAW_Y_SCALE,
441                 event->getHistoricalRawAxisValue(AMOTION_EVENT_AXIS_Y, 0, 1), EPSILON);
442     ASSERT_NEAR(RAW_Y_OFFSET + 121 * RAW_Y_SCALE,
443                 event->getHistoricalRawAxisValue(AMOTION_EVENT_AXIS_Y, 1, 1), EPSILON);
444     ASSERT_NEAR(RAW_Y_OFFSET + 211 * RAW_Y_SCALE, event->getRawAxisValue(AMOTION_EVENT_AXIS_Y, 0),
445                 EPSILON);
446     ASSERT_NEAR(RAW_Y_OFFSET + 221 * RAW_Y_SCALE, event->getRawAxisValue(AMOTION_EVENT_AXIS_Y, 1),
447                 EPSILON);
448 
449     ASSERT_NEAR(RAW_X_OFFSET + 10 * RAW_X_SCALE, event->getHistoricalRawX(0, 0), EPSILON);
450     ASSERT_NEAR(RAW_X_OFFSET + 20 * RAW_X_SCALE, event->getHistoricalRawX(1, 0), EPSILON);
451     ASSERT_NEAR(RAW_X_OFFSET + 110 * RAW_X_SCALE, event->getHistoricalRawX(0, 1), EPSILON);
452     ASSERT_NEAR(RAW_X_OFFSET + 120 * RAW_X_SCALE, event->getHistoricalRawX(1, 1), EPSILON);
453     ASSERT_NEAR(RAW_X_OFFSET + 210 * RAW_X_SCALE, event->getRawX(0), EPSILON);
454     ASSERT_NEAR(RAW_X_OFFSET + 220 * RAW_X_SCALE, event->getRawX(1), EPSILON);
455 
456     ASSERT_NEAR(RAW_Y_OFFSET + 11 * RAW_Y_SCALE, event->getHistoricalRawY(0, 0), EPSILON);
457     ASSERT_NEAR(RAW_Y_OFFSET + 21 * RAW_Y_SCALE, event->getHistoricalRawY(1, 0), EPSILON);
458     ASSERT_NEAR(RAW_Y_OFFSET + 111 * RAW_Y_SCALE, event->getHistoricalRawY(0, 1), EPSILON);
459     ASSERT_NEAR(RAW_Y_OFFSET + 121 * RAW_Y_SCALE, event->getHistoricalRawY(1, 1), EPSILON);
460     ASSERT_NEAR(RAW_Y_OFFSET + 211 * RAW_Y_SCALE, event->getRawY(0), EPSILON);
461     ASSERT_NEAR(RAW_Y_OFFSET + 221 * RAW_Y_SCALE, event->getRawY(1), EPSILON);
462 
463     ASSERT_NEAR(X_OFFSET + 10 * X_SCALE, event->getHistoricalX(0, 0), EPSILON);
464     ASSERT_NEAR(X_OFFSET + 20 * X_SCALE, event->getHistoricalX(1, 0), EPSILON);
465     ASSERT_NEAR(X_OFFSET + 110 * X_SCALE, event->getHistoricalX(0, 1), EPSILON);
466     ASSERT_NEAR(X_OFFSET + 120 * X_SCALE, event->getHistoricalX(1, 1), EPSILON);
467     ASSERT_NEAR(X_OFFSET + 210 * X_SCALE, event->getX(0), EPSILON);
468     ASSERT_NEAR(X_OFFSET + 220 * X_SCALE, event->getX(1), EPSILON);
469 
470     ASSERT_NEAR(Y_OFFSET + 11 * Y_SCALE, event->getHistoricalY(0, 0), EPSILON);
471     ASSERT_NEAR(Y_OFFSET + 21 * Y_SCALE, event->getHistoricalY(1, 0), EPSILON);
472     ASSERT_NEAR(Y_OFFSET + 111 * Y_SCALE, event->getHistoricalY(0, 1), EPSILON);
473     ASSERT_NEAR(Y_OFFSET + 121 * Y_SCALE, event->getHistoricalY(1, 1), EPSILON);
474     ASSERT_NEAR(Y_OFFSET + 211 * Y_SCALE, event->getY(0), EPSILON);
475     ASSERT_NEAR(Y_OFFSET + 221 * Y_SCALE, event->getY(1), EPSILON);
476 
477     ASSERT_EQ(12, event->getHistoricalPressure(0, 0));
478     ASSERT_EQ(22, event->getHistoricalPressure(1, 0));
479     ASSERT_EQ(112, event->getHistoricalPressure(0, 1));
480     ASSERT_EQ(122, event->getHistoricalPressure(1, 1));
481     ASSERT_EQ(212, event->getPressure(0));
482     ASSERT_EQ(222, event->getPressure(1));
483 
484     ASSERT_EQ(13, event->getHistoricalSize(0, 0));
485     ASSERT_EQ(23, event->getHistoricalSize(1, 0));
486     ASSERT_EQ(113, event->getHistoricalSize(0, 1));
487     ASSERT_EQ(123, event->getHistoricalSize(1, 1));
488     ASSERT_EQ(213, event->getSize(0));
489     ASSERT_EQ(223, event->getSize(1));
490 
491     ASSERT_EQ(14, event->getHistoricalTouchMajor(0, 0));
492     ASSERT_EQ(24, event->getHistoricalTouchMajor(1, 0));
493     ASSERT_EQ(114, event->getHistoricalTouchMajor(0, 1));
494     ASSERT_EQ(124, event->getHistoricalTouchMajor(1, 1));
495     ASSERT_EQ(214, event->getTouchMajor(0));
496     ASSERT_EQ(224, event->getTouchMajor(1));
497 
498     ASSERT_EQ(15, event->getHistoricalTouchMinor(0, 0));
499     ASSERT_EQ(25, event->getHistoricalTouchMinor(1, 0));
500     ASSERT_EQ(115, event->getHistoricalTouchMinor(0, 1));
501     ASSERT_EQ(125, event->getHistoricalTouchMinor(1, 1));
502     ASSERT_EQ(215, event->getTouchMinor(0));
503     ASSERT_EQ(225, event->getTouchMinor(1));
504 
505     ASSERT_EQ(16, event->getHistoricalToolMajor(0, 0));
506     ASSERT_EQ(26, event->getHistoricalToolMajor(1, 0));
507     ASSERT_EQ(116, event->getHistoricalToolMajor(0, 1));
508     ASSERT_EQ(126, event->getHistoricalToolMajor(1, 1));
509     ASSERT_EQ(216, event->getToolMajor(0));
510     ASSERT_EQ(226, event->getToolMajor(1));
511 
512     ASSERT_EQ(17, event->getHistoricalToolMinor(0, 0));
513     ASSERT_EQ(27, event->getHistoricalToolMinor(1, 0));
514     ASSERT_EQ(117, event->getHistoricalToolMinor(0, 1));
515     ASSERT_EQ(127, event->getHistoricalToolMinor(1, 1));
516     ASSERT_EQ(217, event->getToolMinor(0));
517     ASSERT_EQ(227, event->getToolMinor(1));
518 
519     // Calculate the orientation after scaling, keeping in mind that an orientation of 0 is "up",
520     // and the positive y direction is "down".
521     auto toScaledOrientation = [](float angle) {
522         const float x = sinf(angle) * X_SCALE;
523         const float y = -cosf(angle) * Y_SCALE;
524         return atan2f(x, -y);
525     };
526     ASSERT_EQ(toScaledOrientation(18), event->getHistoricalOrientation(0, 0));
527     ASSERT_EQ(toScaledOrientation(28), event->getHistoricalOrientation(1, 0));
528     ASSERT_EQ(toScaledOrientation(118), event->getHistoricalOrientation(0, 1));
529     ASSERT_EQ(toScaledOrientation(128), event->getHistoricalOrientation(1, 1));
530     ASSERT_EQ(toScaledOrientation(218), event->getOrientation(0));
531     ASSERT_EQ(toScaledOrientation(228), event->getOrientation(1));
532 
533     ASSERT_TRUE(event->isResampled(0, 0));
534     ASSERT_FALSE(event->isResampled(1, 0));
535     ASSERT_TRUE(event->isResampled(0, 1));
536     ASSERT_TRUE(event->isResampled(1, 1));
537     ASSERT_FALSE(event->isResampled(0, 2));
538     ASSERT_FALSE(event->isResampled(1, 2));
539 }
540 
TEST_F(MotionEventTest,Properties)541 TEST_F(MotionEventTest, Properties) {
542     MotionEvent event;
543 
544     // Initialize, add samples and check properties.
545     initializeEventWithHistory(&event);
546     ASSERT_NO_FATAL_FAILURE(assertEqualsEventWithHistory(&event));
547 
548     // Set source.
549     event.setSource(AINPUT_SOURCE_JOYSTICK);
550     ASSERT_EQ(AINPUT_SOURCE_JOYSTICK, event.getSource());
551 
552     // Set displayId.
553     constexpr ui::LogicalDisplayId newDisplayId = ui::LogicalDisplayId{2};
554     event.setDisplayId(newDisplayId);
555     ASSERT_EQ(newDisplayId, event.getDisplayId());
556 
557     // Set action.
558     event.setAction(AMOTION_EVENT_ACTION_CANCEL);
559     ASSERT_EQ(AMOTION_EVENT_ACTION_CANCEL, event.getAction());
560 
561     // Set meta state.
562     event.setMetaState(AMETA_CTRL_ON);
563     ASSERT_EQ(AMETA_CTRL_ON, event.getMetaState());
564 }
565 
TEST_F(MotionEventTest,CopyFrom_KeepHistory)566 TEST_F(MotionEventTest, CopyFrom_KeepHistory) {
567     MotionEvent event;
568     initializeEventWithHistory(&event);
569 
570     MotionEvent copy;
571     copy.copyFrom(&event, /*keepHistory=*/true);
572 
573     ASSERT_NO_FATAL_FAILURE(assertEqualsEventWithHistory(&event));
574 }
575 
TEST_F(MotionEventTest,CopyFrom_DoNotKeepHistory)576 TEST_F(MotionEventTest, CopyFrom_DoNotKeepHistory) {
577     MotionEvent event;
578     initializeEventWithHistory(&event);
579 
580     MotionEvent copy;
581     copy.copyFrom(&event, /*keepHistory=*/false);
582 
583     ASSERT_EQ(event.getPointerCount(), copy.getPointerCount());
584     ASSERT_EQ(0U, copy.getHistorySize());
585 
586     ASSERT_EQ(event.getPointerId(0), copy.getPointerId(0));
587     ASSERT_EQ(event.getPointerId(1), copy.getPointerId(1));
588 
589     ASSERT_EQ(event.getEventTime(), copy.getEventTime());
590 
591     ASSERT_EQ(event.getX(0), copy.getX(0));
592 }
593 
TEST_F(MotionEventTest,CheckEventIdWithHistoryIsIncremented)594 TEST_F(MotionEventTest, CheckEventIdWithHistoryIsIncremented) {
595     MotionEvent event;
596     constexpr int32_t ARBITRARY_ID = 42;
597     event.initialize(ARBITRARY_ID, 2, AINPUT_SOURCE_TOUCHSCREEN, DISPLAY_ID, INVALID_HMAC,
598                      AMOTION_EVENT_ACTION_MOVE, 0, 0, AMOTION_EVENT_EDGE_FLAG_NONE, AMETA_NONE,
599                      AMOTION_EVENT_BUTTON_PRIMARY, MotionClassification::NONE, mTransform, 0, 0,
600                      AMOTION_EVENT_INVALID_CURSOR_POSITION, AMOTION_EVENT_INVALID_CURSOR_POSITION,
601                      mRawTransform, ARBITRARY_DOWN_TIME, ARBITRARY_EVENT_TIME, 2,
602                      mPointerProperties, mSamples[0].pointerCoords);
603     ASSERT_EQ(event.getId(), ARBITRARY_ID);
604     event.addSample(ARBITRARY_EVENT_TIME + 1, mSamples[1].pointerCoords, ARBITRARY_ID + 1);
605     ASSERT_EQ(event.getId(), ARBITRARY_ID + 1);
606     event.addSample(ARBITRARY_EVENT_TIME + 2, mSamples[2].pointerCoords, ARBITRARY_ID + 2);
607     ASSERT_EQ(event.getId(), ARBITRARY_ID + 2);
608 }
609 
TEST_F(MotionEventTest,SplitPointerDown)610 TEST_F(MotionEventTest, SplitPointerDown) {
611     MotionEvent event = MotionEventBuilder(POINTER_1_DOWN, AINPUT_SOURCE_TOUCHSCREEN)
612                                 .downTime(ARBITRARY_DOWN_TIME)
613                                 .pointer(PointerBuilder(/*id=*/4, ToolType::FINGER).x(4).y(4))
614                                 .pointer(PointerBuilder(/*id=*/6, ToolType::FINGER).x(6).y(6))
615                                 .pointer(PointerBuilder(/*id=*/8, ToolType::FINGER).x(8).y(8))
616                                 .build();
617 
618     MotionEvent splitDown;
619     std::bitset<MAX_POINTER_ID + 1> splitDownIds{};
620     splitDownIds.set(6, true);
621     splitDown.splitFrom(event, splitDownIds, /*eventId=*/42);
622     ASSERT_EQ(splitDown.getAction(), AMOTION_EVENT_ACTION_DOWN);
623     ASSERT_EQ(splitDown.getPointerCount(), 1u);
624     ASSERT_EQ(splitDown.getPointerId(0), 6);
625     ASSERT_EQ(splitDown.getX(0), 6);
626     ASSERT_EQ(splitDown.getY(0), 6);
627 
628     MotionEvent splitPointerDown;
629     std::bitset<MAX_POINTER_ID + 1> splitPointerDownIds{};
630     splitPointerDownIds.set(6, true);
631     splitPointerDownIds.set(8, true);
632     splitPointerDown.splitFrom(event, splitPointerDownIds, /*eventId=*/42);
633     ASSERT_EQ(splitPointerDown.getAction(), POINTER_0_DOWN);
634     ASSERT_EQ(splitPointerDown.getPointerCount(), 2u);
635     ASSERT_EQ(splitPointerDown.getPointerId(0), 6);
636     ASSERT_EQ(splitPointerDown.getX(0), 6);
637     ASSERT_EQ(splitPointerDown.getY(0), 6);
638     ASSERT_EQ(splitPointerDown.getPointerId(1), 8);
639     ASSERT_EQ(splitPointerDown.getX(1), 8);
640     ASSERT_EQ(splitPointerDown.getY(1), 8);
641 
642     MotionEvent splitMove;
643     std::bitset<MAX_POINTER_ID + 1> splitMoveIds{};
644     splitMoveIds.set(4, true);
645     splitMove.splitFrom(event, splitMoveIds, /*eventId=*/43);
646     ASSERT_EQ(splitMove.getAction(), AMOTION_EVENT_ACTION_MOVE);
647     ASSERT_EQ(splitMove.getPointerCount(), 1u);
648     ASSERT_EQ(splitMove.getPointerId(0), 4);
649     ASSERT_EQ(splitMove.getX(0), 4);
650     ASSERT_EQ(splitMove.getY(0), 4);
651 }
652 
TEST_F(MotionEventTest,SplitPointerUp)653 TEST_F(MotionEventTest, SplitPointerUp) {
654     MotionEvent event = MotionEventBuilder(POINTER_0_UP, AINPUT_SOURCE_TOUCHSCREEN)
655                                 .downTime(ARBITRARY_DOWN_TIME)
656                                 .pointer(PointerBuilder(/*id=*/4, ToolType::FINGER).x(4).y(4))
657                                 .pointer(PointerBuilder(/*id=*/6, ToolType::FINGER).x(6).y(6))
658                                 .pointer(PointerBuilder(/*id=*/8, ToolType::FINGER).x(8).y(8))
659                                 .build();
660 
661     MotionEvent splitUp;
662     std::bitset<MAX_POINTER_ID + 1> splitUpIds{};
663     splitUpIds.set(4, true);
664     splitUp.splitFrom(event, splitUpIds, /*eventId=*/42);
665     ASSERT_EQ(splitUp.getAction(), AMOTION_EVENT_ACTION_UP);
666     ASSERT_EQ(splitUp.getPointerCount(), 1u);
667     ASSERT_EQ(splitUp.getPointerId(0), 4);
668     ASSERT_EQ(splitUp.getX(0), 4);
669     ASSERT_EQ(splitUp.getY(0), 4);
670 
671     MotionEvent splitPointerUp;
672     std::bitset<MAX_POINTER_ID + 1> splitPointerUpIds{};
673     splitPointerUpIds.set(4, true);
674     splitPointerUpIds.set(8, true);
675     splitPointerUp.splitFrom(event, splitPointerUpIds, /*eventId=*/42);
676     ASSERT_EQ(splitPointerUp.getAction(), POINTER_0_UP);
677     ASSERT_EQ(splitPointerUp.getPointerCount(), 2u);
678     ASSERT_EQ(splitPointerUp.getPointerId(0), 4);
679     ASSERT_EQ(splitPointerUp.getX(0), 4);
680     ASSERT_EQ(splitPointerUp.getY(0), 4);
681     ASSERT_EQ(splitPointerUp.getPointerId(1), 8);
682     ASSERT_EQ(splitPointerUp.getX(1), 8);
683     ASSERT_EQ(splitPointerUp.getY(1), 8);
684 
685     MotionEvent splitMove;
686     std::bitset<MAX_POINTER_ID + 1> splitMoveIds{};
687     splitMoveIds.set(6, true);
688     splitMoveIds.set(8, true);
689     splitMove.splitFrom(event, splitMoveIds, /*eventId=*/43);
690     ASSERT_EQ(splitMove.getAction(), AMOTION_EVENT_ACTION_MOVE);
691     ASSERT_EQ(splitMove.getPointerCount(), 2u);
692     ASSERT_EQ(splitMove.getPointerId(0), 6);
693     ASSERT_EQ(splitMove.getX(0), 6);
694     ASSERT_EQ(splitMove.getY(0), 6);
695     ASSERT_EQ(splitMove.getPointerId(1), 8);
696     ASSERT_EQ(splitMove.getX(1), 8);
697     ASSERT_EQ(splitMove.getY(1), 8);
698 }
699 
TEST_F(MotionEventTest,SplitPointerUpCancel)700 TEST_F(MotionEventTest, SplitPointerUpCancel) {
701     MotionEvent event = MotionEventBuilder(POINTER_1_UP, AINPUT_SOURCE_TOUCHSCREEN)
702                                 .downTime(ARBITRARY_DOWN_TIME)
703                                 .pointer(PointerBuilder(/*id=*/4, ToolType::FINGER).x(4).y(4))
704                                 .pointer(PointerBuilder(/*id=*/6, ToolType::FINGER).x(6).y(6))
705                                 .pointer(PointerBuilder(/*id=*/8, ToolType::FINGER).x(8).y(8))
706                                 .addFlag(AMOTION_EVENT_FLAG_CANCELED)
707                                 .build();
708 
709     MotionEvent splitUp;
710     std::bitset<MAX_POINTER_ID + 1> splitUpIds{};
711     splitUpIds.set(6, true);
712     splitUp.splitFrom(event, splitUpIds, /*eventId=*/42);
713     ASSERT_EQ(splitUp.getAction(), AMOTION_EVENT_ACTION_CANCEL);
714     ASSERT_EQ(splitUp.getPointerCount(), 1u);
715     ASSERT_EQ(splitUp.getPointerId(0), 6);
716     ASSERT_EQ(splitUp.getX(0), 6);
717     ASSERT_EQ(splitUp.getY(0), 6);
718 }
719 
TEST_F(MotionEventTest,SplitPointerMove)720 TEST_F(MotionEventTest, SplitPointerMove) {
721     MotionEvent event = MotionEventBuilder(AMOTION_EVENT_ACTION_MOVE, AINPUT_SOURCE_TOUCHSCREEN)
722                                 .downTime(ARBITRARY_DOWN_TIME)
723                                 .pointer(PointerBuilder(/*id=*/4, ToolType::FINGER).x(4).y(4))
724                                 .pointer(PointerBuilder(/*id=*/6, ToolType::FINGER).x(6).y(6))
725                                 .pointer(PointerBuilder(/*id=*/8, ToolType::FINGER).x(8).y(8))
726                                 .transform(ui::Transform(ui::Transform::ROT_90, 100, 100))
727                                 .rawTransform(ui::Transform(ui::Transform::FLIP_H, 50, 50))
728                                 .build();
729 
730     MotionEvent splitMove;
731     std::bitset<MAX_POINTER_ID + 1> splitMoveIds{};
732     splitMoveIds.set(4, true);
733     splitMoveIds.set(8, true);
734     splitMove.splitFrom(event, splitMoveIds, /*eventId=*/42);
735     ASSERT_EQ(splitMove.getAction(), AMOTION_EVENT_ACTION_MOVE);
736     ASSERT_EQ(splitMove.getPointerCount(), 2u);
737     ASSERT_EQ(splitMove.getPointerId(0), 4);
738     ASSERT_EQ(splitMove.getX(0), event.getX(0));
739     ASSERT_EQ(splitMove.getY(0), event.getY(0));
740     ASSERT_EQ(splitMove.getRawX(0), event.getRawX(0));
741     ASSERT_EQ(splitMove.getRawY(0), event.getRawY(0));
742     ASSERT_EQ(splitMove.getPointerId(1), 8);
743     ASSERT_EQ(splitMove.getX(1), event.getX(2));
744     ASSERT_EQ(splitMove.getY(1), event.getY(2));
745     ASSERT_EQ(splitMove.getRawX(1), event.getRawX(2));
746     ASSERT_EQ(splitMove.getRawY(1), event.getRawY(2));
747 }
748 
TEST_F(MotionEventTest,OffsetLocation)749 TEST_F(MotionEventTest, OffsetLocation) {
750     MotionEvent event;
751     initializeEventWithHistory(&event);
752     const float xOffset = event.getRawXOffset();
753     const float yOffset = event.getRawYOffset();
754 
755     event.offsetLocation(5.0f, -2.0f);
756 
757     ASSERT_EQ(xOffset + 5.0f, event.getRawXOffset());
758     ASSERT_EQ(yOffset - 2.0f, event.getRawYOffset());
759 }
760 
TEST_F(MotionEventTest,Scale)761 TEST_F(MotionEventTest, Scale) {
762     MotionEvent event;
763     initializeEventWithHistory(&event);
764     const float unscaledOrientation = event.getOrientation(0);
765     const float unscaledXOffset = event.getRawXOffset();
766     const float unscaledYOffset = event.getRawYOffset();
767 
768     event.scale(2.0f);
769 
770     ASSERT_EQ(unscaledXOffset * 2, event.getRawXOffset());
771     ASSERT_EQ(unscaledYOffset * 2, event.getRawYOffset());
772 
773     ASSERT_NEAR((RAW_X_OFFSET + 210 * RAW_X_SCALE) * 2, event.getRawX(0), EPSILON);
774     ASSERT_NEAR((RAW_Y_OFFSET + 211 * RAW_Y_SCALE) * 2, event.getRawY(0), EPSILON);
775     ASSERT_NEAR((X_OFFSET + 210 * X_SCALE) * 2, event.getX(0), EPSILON);
776     ASSERT_NEAR((Y_OFFSET + 211 * Y_SCALE) * 2, event.getY(0), EPSILON);
777     ASSERT_EQ(212, event.getPressure(0));
778     ASSERT_EQ(213, event.getSize(0));
779     ASSERT_EQ(214 * 2, event.getTouchMajor(0));
780     ASSERT_EQ(215 * 2, event.getTouchMinor(0));
781     ASSERT_EQ(216 * 2, event.getToolMajor(0));
782     ASSERT_EQ(217 * 2, event.getToolMinor(0));
783     ASSERT_EQ(unscaledOrientation, event.getOrientation(0));
784 }
785 
TEST_F(MotionEventTest,Parcel)786 TEST_F(MotionEventTest, Parcel) {
787     Parcel parcel;
788 
789     MotionEvent inEvent;
790     initializeEventWithHistory(&inEvent);
791     MotionEvent outEvent;
792 
793     // Round trip.
794     inEvent.writeToParcel(&parcel);
795     parcel.setDataPosition(0);
796     outEvent.readFromParcel(&parcel);
797 
798     ASSERT_NO_FATAL_FAILURE(assertEqualsEventWithHistory(&outEvent));
799 }
800 
setRotationMatrix(std::array<float,9> & matrix,float angle)801 static void setRotationMatrix(std::array<float, 9>& matrix, float angle) {
802     float sin = sinf(angle);
803     float cos = cosf(angle);
804     matrix[0] = cos;
805     matrix[1] = -sin;
806     matrix[2] = 0;
807     matrix[3] = sin;
808     matrix[4] = cos;
809     matrix[5] = 0;
810     matrix[6] = 0;
811     matrix[7] = 0;
812     matrix[8] = 1.0f;
813 }
814 
TEST_F(MotionEventTest,Transform)815 TEST_F(MotionEventTest, Transform) {
816     // Generate some points on a circle.
817     // Each point 'i' is a point on a circle of radius ROTATION centered at (3,2) at an angle
818     // of ARC * i degrees clockwise relative to the Y axis.
819     // The geometrical representation is irrelevant to the test, it's just easy to generate
820     // and check rotation.  We set the orientation to the same angle.
821     // Coordinate system: down is increasing Y, right is increasing X.
822     static constexpr float PI_180 = float(M_PI / 180);
823     static constexpr float RADIUS = 10;
824     static constexpr float ARC = 36;
825     static constexpr float ROTATION = ARC * 2;
826 
827     const size_t pointerCount = 11;
828     PointerProperties pointerProperties[pointerCount];
829     PointerCoords pointerCoords[pointerCount];
830     for (size_t i = 0; i < pointerCount; i++) {
831         float angle = float(i * ARC * PI_180);
832         pointerProperties[i].clear();
833         pointerProperties[i].id = i;
834         pointerCoords[i].clear();
835         pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_X, sinf(angle) * RADIUS + 3);
836         pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_Y, -cosf(angle) * RADIUS + 2);
837         pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, angle);
838     }
839     MotionEvent event;
840     ui::Transform identityTransform;
841     const int32_t flags = AMOTION_EVENT_PRIVATE_FLAG_SUPPORTS_ORIENTATION |
842             AMOTION_EVENT_PRIVATE_FLAG_SUPPORTS_DIRECTIONAL_ORIENTATION;
843     event.initialize(InputEvent::nextId(), /*deviceId=*/0, AINPUT_SOURCE_TOUCHSCREEN, DISPLAY_ID,
844                      INVALID_HMAC, AMOTION_EVENT_ACTION_MOVE, /*actionButton=*/0, flags,
845                      AMOTION_EVENT_EDGE_FLAG_NONE, AMETA_NONE, /*buttonState=*/0,
846                      MotionClassification::NONE, identityTransform, /*xPrecision=*/0,
847                      /*yPrecision=*/0, /*xCursorPosition=*/3 + RADIUS, /*yCursorPosition=*/2,
848                      identityTransform, /*downTime=*/0, /*eventTime=*/0, pointerCount,
849                      pointerProperties, pointerCoords);
850     float originalRawX = 0 + 3;
851     float originalRawY = -RADIUS + 2;
852 
853     // Check original raw X and Y assumption.
854     ASSERT_NEAR(originalRawX, event.getRawX(0), 0.001);
855     ASSERT_NEAR(originalRawY, event.getRawY(0), 0.001);
856 
857     // Now translate the motion event so the circle's origin is at (0,0).
858     event.offsetLocation(-3, -2);
859 
860     // Offsetting the location should preserve the raw X and Y of the first point.
861     ASSERT_NEAR(originalRawX, event.getRawX(0), 0.001);
862     ASSERT_NEAR(originalRawY, event.getRawY(0), 0.001);
863 
864     // Apply a rotation about the origin by ROTATION degrees clockwise.
865     std::array<float, 9> matrix;
866     setRotationMatrix(matrix, ROTATION * PI_180);
867     event.transform(matrix);
868 
869     // Check the points.
870     for (size_t i = 0; i < pointerCount; i++) {
871         float angle = float((i * ARC + ROTATION) * PI_180);
872         ASSERT_NEAR(sinf(angle) * RADIUS, event.getX(i), 0.001);
873         ASSERT_NEAR(-cosf(angle) * RADIUS, event.getY(i), 0.001);
874         ASSERT_NEAR(tanf(angle), tanf(event.getOrientation(i)), 0.1);
875     }
876 
877     // Check cursor positions. The original cursor position is at (3 + RADIUS, 2), where the center
878     // of the circle is (3, 2), so the cursor position is to the right of the center of the circle.
879     // The choice of triangular functions in this test defines the angle of rotation clockwise
880     // relative to the y-axis. Therefore the cursor position's angle is 90 degrees. Here we swap the
881     // triangular function so that we don't have to add the 90 degrees.
882     ASSERT_NEAR(cosf(PI_180 * ROTATION) * RADIUS, event.getXCursorPosition(), 0.001);
883     ASSERT_NEAR(sinf(PI_180 * ROTATION) * RADIUS, event.getYCursorPosition(), 0.001);
884 
885     // Applying the transformation should preserve the raw X and Y of the first point.
886     ASSERT_NEAR(originalRawX, event.getRawX(0), 0.001);
887     ASSERT_NEAR(originalRawY, event.getRawY(0), 0.001);
888 }
889 
createMotionEvent(int32_t source,uint32_t action,float x,float y,float dx,float dy,const ui::Transform & transform,const ui::Transform & rawTransform)890 MotionEvent createMotionEvent(int32_t source, uint32_t action, float x, float y, float dx, float dy,
891                               const ui::Transform& transform, const ui::Transform& rawTransform) {
892     std::vector<PointerProperties> pointerProperties;
893     pointerProperties.push_back(PointerProperties{/*id=*/0, ToolType::FINGER});
894     std::vector<PointerCoords> pointerCoords;
895     pointerCoords.emplace_back().clear();
896     pointerCoords.back().setAxisValue(AMOTION_EVENT_AXIS_X, x);
897     pointerCoords.back().setAxisValue(AMOTION_EVENT_AXIS_Y, y);
898     pointerCoords.back().setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, dx);
899     pointerCoords.back().setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, dy);
900     nsecs_t eventTime = systemTime(SYSTEM_TIME_MONOTONIC);
901     MotionEvent event;
902     event.initialize(InputEvent::nextId(), /*deviceId=*/1, source, ui::LogicalDisplayId::DEFAULT,
903                      INVALID_HMAC, action, /*actionButton=*/0, /*flags=*/0, /*edgeFlags=*/0,
904                      AMETA_NONE, /*buttonState=*/0, MotionClassification::NONE, transform,
905                      /*xPrecision=*/0, /*yPrecision=*/0, AMOTION_EVENT_INVALID_CURSOR_POSITION,
906                      AMOTION_EVENT_INVALID_CURSOR_POSITION, rawTransform, eventTime, eventTime,
907                      pointerCoords.size(), pointerProperties.data(), pointerCoords.data());
908     return event;
909 }
910 
createTouchDownEvent(float x,float y,float dx,float dy,const ui::Transform & transform,const ui::Transform & rawTransform)911 MotionEvent createTouchDownEvent(float x, float y, float dx, float dy,
912                                  const ui::Transform& transform,
913                                  const ui::Transform& rawTransform) {
914     return createMotionEvent(AINPUT_SOURCE_TOUCHSCREEN, AMOTION_EVENT_ACTION_DOWN, x, y, dx, dy,
915                              transform, rawTransform);
916 }
917 
TEST_F(MotionEventTest,ApplyTransform)918 TEST_F(MotionEventTest, ApplyTransform) {
919     // Create a rotate-90 transform with an offset (like a window which isn't fullscreen).
920     ui::Transform identity;
921     ui::Transform transform(ui::Transform::ROT_90, 800, 400);
922     transform.set(transform.tx() + 20, transform.ty() + 40);
923     ui::Transform rawTransform(ui::Transform::ROT_90, 800, 400);
924     MotionEvent event = createTouchDownEvent(60, 100, 42, 96, transform, rawTransform);
925     ASSERT_EQ(700, event.getRawX(0));
926     ASSERT_EQ(60, event.getRawY(0));
927     ASSERT_NE(event.getRawX(0), event.getX(0));
928     ASSERT_NE(event.getRawY(0), event.getY(0));
929     // Relative values should be rotated but not translated.
930     ASSERT_EQ(-96, event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, 0));
931     ASSERT_EQ(42, event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, 0));
932 
933     MotionEvent changedEvent = createTouchDownEvent(60, 100, 42, 96, identity, identity);
934     const std::array<float, 9> rowMajor{transform[0][0], transform[1][0], transform[2][0],
935                                         transform[0][1], transform[1][1], transform[2][1],
936                                         transform[0][2], transform[1][2], transform[2][2]};
937     changedEvent.applyTransform(rowMajor);
938 
939     // transformContent effectively rotates the raw coordinates, so those should now include
940     // both rotation AND offset.
941     ASSERT_EQ(720, changedEvent.getRawX(0));
942     ASSERT_EQ(100, changedEvent.getRawY(0));
943     // Relative values should be rotated but not translated.
944     ASSERT_EQ(-96, event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, 0));
945     ASSERT_EQ(42, event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, 0));
946 
947     // The transformed output should be the same then.
948     ASSERT_NEAR(event.getX(0), changedEvent.getX(0), 0.001);
949     ASSERT_NEAR(event.getY(0), changedEvent.getY(0), 0.001);
950     ASSERT_NEAR(event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, 0),
951                 changedEvent.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, 0), 0.001);
952     ASSERT_NEAR(event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, 0),
953                 changedEvent.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, 0), 0.001);
954 }
955 
TEST_F(MotionEventTest,JoystickAndTouchpadAreNotTransformed)956 TEST_F(MotionEventTest, JoystickAndTouchpadAreNotTransformed) {
957     constexpr static std::array kNonTransformedSources =
958             {std::pair(AINPUT_SOURCE_TOUCHPAD, AMOTION_EVENT_ACTION_DOWN),
959              std::pair(AINPUT_SOURCE_JOYSTICK, AMOTION_EVENT_ACTION_MOVE),
960              std::pair(AINPUT_SOURCE_MOUSE_RELATIVE, AMOTION_EVENT_ACTION_MOVE)};
961     // Create a rotate-90 transform with an offset (like a window which isn't fullscreen).
962     ui::Transform transform(ui::Transform::ROT_90, 800, 400);
963     transform.set(transform.tx() + 20, transform.ty() + 40);
964 
965     for (const auto& [source, action] : kNonTransformedSources) {
966         const MotionEvent event =
967                 createMotionEvent(source, action, 60, 100, 0, 0, transform, transform);
968 
969         // These events should not be transformed in any way.
970         ASSERT_EQ(60, event.getX(0));
971         ASSERT_EQ(100, event.getY(0));
972         ASSERT_EQ(event.getRawX(0), event.getX(0));
973         ASSERT_EQ(event.getRawY(0), event.getY(0));
974     }
975 }
976 
TEST_F(MotionEventTest,NonPointerSourcesAreNotTranslated)977 TEST_F(MotionEventTest, NonPointerSourcesAreNotTranslated) {
978     constexpr static std::array kNonPointerSources = {std::pair(AINPUT_SOURCE_TRACKBALL,
979                                                                 AMOTION_EVENT_ACTION_DOWN),
980                                                       std::pair(AINPUT_SOURCE_TOUCH_NAVIGATION,
981                                                                 AMOTION_EVENT_ACTION_MOVE)};
982     // Create a rotate-90 transform with an offset (like a window which isn't fullscreen).
983     ui::Transform transform(ui::Transform::ROT_90, 800, 400);
984     transform.set(transform.tx() + 20, transform.ty() + 40);
985 
986     for (const auto& [source, action] : kNonPointerSources) {
987         const MotionEvent event =
988                 createMotionEvent(source, action, 60, 100, 42, 96, transform, transform);
989 
990         // Since this event comes from a non-pointer source, it should include rotation but not
991         // translation/offset.
992         ASSERT_EQ(-100, event.getX(0));
993         ASSERT_EQ(60, event.getY(0));
994         ASSERT_EQ(event.getRawX(0), event.getX(0));
995         ASSERT_EQ(event.getRawY(0), event.getY(0));
996     }
997 }
998 
TEST_F(MotionEventTest,AxesAreCorrectlyTransformed)999 TEST_F(MotionEventTest, AxesAreCorrectlyTransformed) {
1000     const ui::Transform identity;
1001     ui::Transform transform;
1002     transform.set({1.1, -2.2, 3.3, -4.4, 5.5, -6.6, 0, 0, 1});
1003     ui::Transform rawTransform;
1004     rawTransform.set({-6.6, 5.5, -4.4, 3.3, -2.2, 1.1, 0, 0, 1});
1005     auto transformWithoutTranslation = [](const ui::Transform& t, float x, float y) {
1006         auto newPoint = t.transform(x, y);
1007         auto newOrigin = t.transform(0, 0);
1008         return newPoint - newOrigin;
1009     };
1010 
1011     const MotionEvent event = createTouchDownEvent(60, 100, 42, 96, transform, rawTransform);
1012 
1013     // The x and y axes should have the window transform applied.
1014     const auto newPoint = transform.transform(60, 100);
1015     ASSERT_NEAR(newPoint.x, event.getX(0), EPSILON);
1016     ASSERT_NEAR(newPoint.y, event.getY(0), EPSILON);
1017 
1018     // The raw values should have the display transform applied.
1019     const auto raw = rawTransform.transform(60, 100);
1020     ASSERT_NEAR(raw.x, event.getRawX(0), EPSILON);
1021     ASSERT_NEAR(raw.y, event.getRawY(0), EPSILON);
1022 
1023     // Relative values should have the window transform applied without any translation.
1024     const auto rel = transformWithoutTranslation(transform, 42, 96);
1025     ASSERT_NEAR(rel.x, event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, 0), EPSILON);
1026     ASSERT_NEAR(rel.y, event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, 0), EPSILON);
1027 }
1028 
TEST_F(MotionEventTest,Initialize_SetsClassification)1029 TEST_F(MotionEventTest, Initialize_SetsClassification) {
1030     std::array<MotionClassification, 3> classifications = {
1031             MotionClassification::NONE,
1032             MotionClassification::AMBIGUOUS_GESTURE,
1033             MotionClassification::DEEP_PRESS,
1034     };
1035 
1036     MotionEvent event;
1037     constexpr size_t pointerCount = 1;
1038     PointerProperties pointerProperties[pointerCount];
1039     PointerCoords pointerCoords[pointerCount];
1040     for (size_t i = 0; i < pointerCount; i++) {
1041         pointerProperties[i].clear();
1042         pointerProperties[i].id = i;
1043         pointerCoords[i].clear();
1044     }
1045 
1046     ui::Transform identityTransform;
1047     for (MotionClassification classification : classifications) {
1048         event.initialize(InputEvent::nextId(), /*deviceId=*/0, AINPUT_SOURCE_TOUCHSCREEN,
1049                          DISPLAY_ID, INVALID_HMAC, AMOTION_EVENT_ACTION_DOWN, 0, 0,
1050                          AMOTION_EVENT_EDGE_FLAG_NONE, AMETA_NONE, 0, classification,
1051                          identityTransform, 0, 0, AMOTION_EVENT_INVALID_CURSOR_POSITION,
1052                          AMOTION_EVENT_INVALID_CURSOR_POSITION, identityTransform, /*downTime=*/0,
1053                          /*eventTime=*/0, pointerCount, pointerProperties, pointerCoords);
1054         ASSERT_EQ(classification, event.getClassification());
1055     }
1056 }
1057 
TEST_F(MotionEventTest,Initialize_SetsCursorPosition)1058 TEST_F(MotionEventTest, Initialize_SetsCursorPosition) {
1059     MotionEvent event;
1060     constexpr size_t pointerCount = 1;
1061     PointerProperties pointerProperties[pointerCount];
1062     PointerCoords pointerCoords[pointerCount];
1063     for (size_t i = 0; i < pointerCount; i++) {
1064         pointerProperties[i].clear();
1065         pointerProperties[i].id = i;
1066         pointerCoords[i].clear();
1067     }
1068 
1069     ui::Transform identityTransform;
1070     event.initialize(InputEvent::nextId(), /*deviceId=*/0, AINPUT_SOURCE_MOUSE, DISPLAY_ID,
1071                      INVALID_HMAC, AMOTION_EVENT_ACTION_DOWN, 0, 0, AMOTION_EVENT_EDGE_FLAG_NONE,
1072                      AMETA_NONE, 0, MotionClassification::NONE, identityTransform, 0, 0,
1073                      /*xCursorPosition=*/280, /*yCursorPosition=*/540, identityTransform,
1074                      /*downTime=*/0, /*eventTime=*/0, pointerCount, pointerProperties,
1075                      pointerCoords);
1076     event.offsetLocation(20, 60);
1077     ASSERT_EQ(280, event.getRawXCursorPosition());
1078     ASSERT_EQ(540, event.getRawYCursorPosition());
1079     ASSERT_EQ(300, event.getXCursorPosition());
1080     ASSERT_EQ(600, event.getYCursorPosition());
1081 }
1082 
TEST_F(MotionEventTest,SetCursorPosition)1083 TEST_F(MotionEventTest, SetCursorPosition) {
1084     MotionEvent event;
1085     initializeEventWithHistory(&event);
1086     event.setSource(AINPUT_SOURCE_MOUSE);
1087 
1088     event.setCursorPosition(3, 4);
1089     ASSERT_EQ(3, event.getXCursorPosition());
1090     ASSERT_EQ(4, event.getYCursorPosition());
1091 }
1092 
TEST_F(MotionEventTest,CoordinatesAreRoundedAppropriately)1093 TEST_F(MotionEventTest, CoordinatesAreRoundedAppropriately) {
1094     // These are specifically integral values, since we are testing for rounding.
1095     const vec2 EXPECTED{400.f, 700.f};
1096 
1097     // Pick a transform such that transforming the point with its inverse and bringing that
1098     // back to the original coordinate space results in a non-zero error amount due to the
1099     // nature of floating point arithmetics. This can happen when the display is scaled.
1100     // For example, the 'adb shell wm size' command can be used to set an override for the
1101     // logical display size, which could result in the display being scaled.
1102     constexpr float scale = 720.f / 1080.f;
1103     ui::Transform transform;
1104     transform.set(scale, 0, 0, scale);
1105     ASSERT_NE(EXPECTED, transform.transform(transform.inverse().transform(EXPECTED)));
1106 
1107     // Store the inverse-transformed values in the motion event.
1108     const vec2 rawCoords = transform.inverse().transform(EXPECTED);
1109     PointerCoords pc{};
1110     pc.setAxisValue(AMOTION_EVENT_AXIS_X, rawCoords.x);
1111     pc.setAxisValue(AMOTION_EVENT_AXIS_Y, rawCoords.y);
1112     PointerProperties pp{};
1113     MotionEvent event;
1114     event.initialize(InputEvent::nextId(), 2, AINPUT_SOURCE_TOUCHSCREEN, DISPLAY_ID, HMAC,
1115                      AMOTION_EVENT_ACTION_MOVE, 0, AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED,
1116                      AMOTION_EVENT_EDGE_FLAG_TOP, AMETA_ALT_ON, AMOTION_EVENT_BUTTON_PRIMARY,
1117                      MotionClassification::NONE, transform, 2.0f, 2.1f, rawCoords.x, rawCoords.y,
1118                      transform, ARBITRARY_DOWN_TIME, ARBITRARY_EVENT_TIME, 1, &pp, &pc);
1119 
1120     // When using the getters from the MotionEvent to obtain the coordinates, the transformed
1121     // values should be rounded by an appropriate amount so that they now precisely equal the
1122     // original coordinates.
1123     ASSERT_EQ(EXPECTED.x, event.getX(0));
1124     ASSERT_EQ(EXPECTED.y, event.getY(0));
1125     ASSERT_EQ(EXPECTED.x, event.getRawX(0));
1126     ASSERT_EQ(EXPECTED.y, event.getRawY(0));
1127     ASSERT_EQ(EXPECTED.x, event.getXCursorPosition());
1128     ASSERT_EQ(EXPECTED.y, event.getYCursorPosition());
1129 }
1130 
TEST_F(MotionEventTest,InvalidOrientationNotRotated)1131 TEST_F(MotionEventTest, InvalidOrientationNotRotated) {
1132     // This touch event does not have a value for AXIS_ORIENTATION, and the flags are implicitly
1133     // set to 0. The transform is set to a 90-degree rotation.
1134     MotionEvent event = MotionEventBuilder(AMOTION_EVENT_ACTION_MOVE, AINPUT_SOURCE_TOUCHSCREEN)
1135                                 .downTime(ARBITRARY_DOWN_TIME)
1136                                 .pointer(PointerBuilder(/*id=*/4, ToolType::FINGER).x(4).y(4))
1137                                 .transform(ui::Transform(ui::Transform::ROT_90, 100, 100))
1138                                 .rawTransform(ui::Transform(ui::Transform::FLIP_H, 50, 50))
1139                                 .build();
1140     ASSERT_EQ(event.getOrientation(/*pointerIndex=*/0), 0.f);
1141     event.transform(asFloat9(ui::Transform(ui::Transform::ROT_90, 100, 100)));
1142     ASSERT_EQ(event.getOrientation(/*pointerIndex=*/0), 0.f);
1143     event.transform(asFloat9(ui::Transform(ui::Transform::ROT_180, 100, 100)));
1144     ASSERT_EQ(event.getOrientation(/*pointerIndex=*/0), 0.f);
1145     event.applyTransform(asFloat9(ui::Transform(ui::Transform::ROT_270, 100, 100)));
1146     ASSERT_EQ(event.getOrientation(/*pointerIndex=*/0), 0.f);
1147 }
1148 
TEST_F(MotionEventTest,ValidZeroOrientationRotated)1149 TEST_F(MotionEventTest, ValidZeroOrientationRotated) {
1150     // This touch events will implicitly have a value of 0 for its AXIS_ORIENTATION.
1151     auto builder = MotionEventBuilder(AMOTION_EVENT_ACTION_MOVE, AINPUT_SOURCE_TOUCHSCREEN)
1152                            .downTime(ARBITRARY_DOWN_TIME)
1153                            .pointer(PointerBuilder(/*id=*/4, ToolType::FINGER).x(4).y(4))
1154                            .transform(ui::Transform(ui::Transform::ROT_90, 100, 100))
1155                            .rawTransform(ui::Transform(ui::Transform::FLIP_H, 50, 50))
1156                            .addFlag(AMOTION_EVENT_PRIVATE_FLAG_SUPPORTS_ORIENTATION);
1157     MotionEvent nonDirectionalEvent = builder.build();
1158     MotionEvent directionalEvent =
1159             builder.addFlag(AMOTION_EVENT_PRIVATE_FLAG_SUPPORTS_DIRECTIONAL_ORIENTATION).build();
1160 
1161     // The angle is rotated by the initial transform, a 90-degree rotation.
1162     ASSERT_NEAR(fabs(nonDirectionalEvent.getOrientation(/*pointerIndex=*/0)), M_PI_2, EPSILON);
1163     ASSERT_NEAR(directionalEvent.getOrientation(/*pointerIndex=*/0), M_PI_2, EPSILON);
1164 
1165     nonDirectionalEvent.transform(asFloat9(ui::Transform(ui::Transform::ROT_90, 100, 100)));
1166     directionalEvent.transform(asFloat9(ui::Transform(ui::Transform::ROT_90, 100, 100)));
1167     ASSERT_NEAR(nonDirectionalEvent.getOrientation(/*pointerIndex=*/0), 0.f, EPSILON);
1168     ASSERT_NEAR(fabs(directionalEvent.getOrientation(/*pointerIndex=*/0)), M_PI, EPSILON);
1169 
1170     nonDirectionalEvent.transform(asFloat9(ui::Transform(ui::Transform::ROT_180, 100, 100)));
1171     directionalEvent.transform(asFloat9(ui::Transform(ui::Transform::ROT_180, 100, 100)));
1172     ASSERT_NEAR(nonDirectionalEvent.getOrientation(/*pointerIndex=*/0), 0.f, EPSILON);
1173     ASSERT_NEAR(directionalEvent.getOrientation(/*pointerIndex=*/0), 0.f, EPSILON);
1174 
1175     nonDirectionalEvent.applyTransform(asFloat9(ui::Transform(ui::Transform::ROT_270, 100, 100)));
1176     directionalEvent.applyTransform(asFloat9(ui::Transform(ui::Transform::ROT_270, 100, 100)));
1177     ASSERT_NEAR(fabs(nonDirectionalEvent.getOrientation(/*pointerIndex=*/0)), M_PI_2, EPSILON);
1178     ASSERT_NEAR(directionalEvent.getOrientation(/*pointerIndex=*/0), -M_PI_2, EPSILON);
1179 }
1180 
TEST_F(MotionEventTest,ValidNonZeroOrientationRotated)1181 TEST_F(MotionEventTest, ValidNonZeroOrientationRotated) {
1182     const float initial = 1.f;
1183     auto builder = MotionEventBuilder(AMOTION_EVENT_ACTION_MOVE, AINPUT_SOURCE_TOUCHSCREEN)
1184                            .downTime(ARBITRARY_DOWN_TIME)
1185                            .pointer(PointerBuilder(/*id=*/4, ToolType::FINGER)
1186                                             .x(4)
1187                                             .y(4)
1188                                             .axis(AMOTION_EVENT_AXIS_ORIENTATION, initial))
1189                            .transform(ui::Transform(ui::Transform::ROT_90, 100, 100))
1190                            .rawTransform(ui::Transform(ui::Transform::FLIP_H, 50, 50))
1191                            .addFlag(AMOTION_EVENT_PRIVATE_FLAG_SUPPORTS_ORIENTATION);
1192 
1193     MotionEvent nonDirectionalEvent = builder.build();
1194     MotionEvent directionalEvent =
1195             builder.addFlag(AMOTION_EVENT_PRIVATE_FLAG_SUPPORTS_DIRECTIONAL_ORIENTATION).build();
1196 
1197     // The angle is rotated by the initial transform, a 90-degree rotation.
1198     ASSERT_NEAR(nonDirectionalEvent.getOrientation(/*pointerIndex=*/0), initial - M_PI_2, EPSILON);
1199     ASSERT_NEAR(directionalEvent.getOrientation(/*pointerIndex=*/0), initial + M_PI_2, EPSILON);
1200 
1201     nonDirectionalEvent.transform(asFloat9(ui::Transform(ui::Transform::ROT_90, 100, 100)));
1202     directionalEvent.transform(asFloat9(ui::Transform(ui::Transform::ROT_90, 100, 100)));
1203     ASSERT_NEAR(nonDirectionalEvent.getOrientation(/*pointerIndex=*/0), initial, EPSILON);
1204     ASSERT_NEAR(directionalEvent.getOrientation(/*pointerIndex=*/0), initial - M_PI, EPSILON);
1205 
1206     nonDirectionalEvent.transform(asFloat9(ui::Transform(ui::Transform::ROT_180, 100, 100)));
1207     directionalEvent.transform(asFloat9(ui::Transform(ui::Transform::ROT_180, 100, 100)));
1208     ASSERT_NEAR(nonDirectionalEvent.getOrientation(/*pointerIndex=*/0), initial, EPSILON);
1209     ASSERT_NEAR(directionalEvent.getOrientation(/*pointerIndex=*/0), initial, EPSILON);
1210 
1211     nonDirectionalEvent.applyTransform(asFloat9(ui::Transform(ui::Transform::ROT_270, 100, 100)));
1212     directionalEvent.applyTransform(asFloat9(ui::Transform(ui::Transform::ROT_270, 100, 100)));
1213     ASSERT_NEAR(nonDirectionalEvent.getOrientation(/*pointerIndex=*/0), initial - M_PI_2, EPSILON);
1214     ASSERT_NEAR(directionalEvent.getOrientation(/*pointerIndex=*/0), initial - M_PI_2, EPSILON);
1215 }
1216 
1217 } // namespace android
1218