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);
375     event->addSample(ARBITRARY_EVENT_TIME + 2, mSamples[2].pointerCoords);
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,SplitPointerDown)594 TEST_F(MotionEventTest, SplitPointerDown) {
595     MotionEvent event = MotionEventBuilder(POINTER_1_DOWN, AINPUT_SOURCE_TOUCHSCREEN)
596                                 .downTime(ARBITRARY_DOWN_TIME)
597                                 .pointer(PointerBuilder(/*id=*/4, ToolType::FINGER).x(4).y(4))
598                                 .pointer(PointerBuilder(/*id=*/6, ToolType::FINGER).x(6).y(6))
599                                 .pointer(PointerBuilder(/*id=*/8, ToolType::FINGER).x(8).y(8))
600                                 .build();
601 
602     MotionEvent splitDown;
603     std::bitset<MAX_POINTER_ID + 1> splitDownIds{};
604     splitDownIds.set(6, true);
605     splitDown.splitFrom(event, splitDownIds, /*eventId=*/42);
606     ASSERT_EQ(splitDown.getAction(), AMOTION_EVENT_ACTION_DOWN);
607     ASSERT_EQ(splitDown.getPointerCount(), 1u);
608     ASSERT_EQ(splitDown.getPointerId(0), 6);
609     ASSERT_EQ(splitDown.getX(0), 6);
610     ASSERT_EQ(splitDown.getY(0), 6);
611 
612     MotionEvent splitPointerDown;
613     std::bitset<MAX_POINTER_ID + 1> splitPointerDownIds{};
614     splitPointerDownIds.set(6, true);
615     splitPointerDownIds.set(8, true);
616     splitPointerDown.splitFrom(event, splitPointerDownIds, /*eventId=*/42);
617     ASSERT_EQ(splitPointerDown.getAction(), POINTER_0_DOWN);
618     ASSERT_EQ(splitPointerDown.getPointerCount(), 2u);
619     ASSERT_EQ(splitPointerDown.getPointerId(0), 6);
620     ASSERT_EQ(splitPointerDown.getX(0), 6);
621     ASSERT_EQ(splitPointerDown.getY(0), 6);
622     ASSERT_EQ(splitPointerDown.getPointerId(1), 8);
623     ASSERT_EQ(splitPointerDown.getX(1), 8);
624     ASSERT_EQ(splitPointerDown.getY(1), 8);
625 
626     MotionEvent splitMove;
627     std::bitset<MAX_POINTER_ID + 1> splitMoveIds{};
628     splitMoveIds.set(4, true);
629     splitMove.splitFrom(event, splitMoveIds, /*eventId=*/43);
630     ASSERT_EQ(splitMove.getAction(), AMOTION_EVENT_ACTION_MOVE);
631     ASSERT_EQ(splitMove.getPointerCount(), 1u);
632     ASSERT_EQ(splitMove.getPointerId(0), 4);
633     ASSERT_EQ(splitMove.getX(0), 4);
634     ASSERT_EQ(splitMove.getY(0), 4);
635 }
636 
TEST_F(MotionEventTest,SplitPointerUp)637 TEST_F(MotionEventTest, SplitPointerUp) {
638     MotionEvent event = MotionEventBuilder(POINTER_0_UP, AINPUT_SOURCE_TOUCHSCREEN)
639                                 .downTime(ARBITRARY_DOWN_TIME)
640                                 .pointer(PointerBuilder(/*id=*/4, ToolType::FINGER).x(4).y(4))
641                                 .pointer(PointerBuilder(/*id=*/6, ToolType::FINGER).x(6).y(6))
642                                 .pointer(PointerBuilder(/*id=*/8, ToolType::FINGER).x(8).y(8))
643                                 .build();
644 
645     MotionEvent splitUp;
646     std::bitset<MAX_POINTER_ID + 1> splitUpIds{};
647     splitUpIds.set(4, true);
648     splitUp.splitFrom(event, splitUpIds, /*eventId=*/42);
649     ASSERT_EQ(splitUp.getAction(), AMOTION_EVENT_ACTION_UP);
650     ASSERT_EQ(splitUp.getPointerCount(), 1u);
651     ASSERT_EQ(splitUp.getPointerId(0), 4);
652     ASSERT_EQ(splitUp.getX(0), 4);
653     ASSERT_EQ(splitUp.getY(0), 4);
654 
655     MotionEvent splitPointerUp;
656     std::bitset<MAX_POINTER_ID + 1> splitPointerUpIds{};
657     splitPointerUpIds.set(4, true);
658     splitPointerUpIds.set(8, true);
659     splitPointerUp.splitFrom(event, splitPointerUpIds, /*eventId=*/42);
660     ASSERT_EQ(splitPointerUp.getAction(), POINTER_0_UP);
661     ASSERT_EQ(splitPointerUp.getPointerCount(), 2u);
662     ASSERT_EQ(splitPointerUp.getPointerId(0), 4);
663     ASSERT_EQ(splitPointerUp.getX(0), 4);
664     ASSERT_EQ(splitPointerUp.getY(0), 4);
665     ASSERT_EQ(splitPointerUp.getPointerId(1), 8);
666     ASSERT_EQ(splitPointerUp.getX(1), 8);
667     ASSERT_EQ(splitPointerUp.getY(1), 8);
668 
669     MotionEvent splitMove;
670     std::bitset<MAX_POINTER_ID + 1> splitMoveIds{};
671     splitMoveIds.set(6, true);
672     splitMoveIds.set(8, true);
673     splitMove.splitFrom(event, splitMoveIds, /*eventId=*/43);
674     ASSERT_EQ(splitMove.getAction(), AMOTION_EVENT_ACTION_MOVE);
675     ASSERT_EQ(splitMove.getPointerCount(), 2u);
676     ASSERT_EQ(splitMove.getPointerId(0), 6);
677     ASSERT_EQ(splitMove.getX(0), 6);
678     ASSERT_EQ(splitMove.getY(0), 6);
679     ASSERT_EQ(splitMove.getPointerId(1), 8);
680     ASSERT_EQ(splitMove.getX(1), 8);
681     ASSERT_EQ(splitMove.getY(1), 8);
682 }
683 
TEST_F(MotionEventTest,SplitPointerUpCancel)684 TEST_F(MotionEventTest, SplitPointerUpCancel) {
685     MotionEvent event = MotionEventBuilder(POINTER_1_UP, AINPUT_SOURCE_TOUCHSCREEN)
686                                 .downTime(ARBITRARY_DOWN_TIME)
687                                 .pointer(PointerBuilder(/*id=*/4, ToolType::FINGER).x(4).y(4))
688                                 .pointer(PointerBuilder(/*id=*/6, ToolType::FINGER).x(6).y(6))
689                                 .pointer(PointerBuilder(/*id=*/8, ToolType::FINGER).x(8).y(8))
690                                 .addFlag(AMOTION_EVENT_FLAG_CANCELED)
691                                 .build();
692 
693     MotionEvent splitUp;
694     std::bitset<MAX_POINTER_ID + 1> splitUpIds{};
695     splitUpIds.set(6, true);
696     splitUp.splitFrom(event, splitUpIds, /*eventId=*/42);
697     ASSERT_EQ(splitUp.getAction(), AMOTION_EVENT_ACTION_CANCEL);
698     ASSERT_EQ(splitUp.getPointerCount(), 1u);
699     ASSERT_EQ(splitUp.getPointerId(0), 6);
700     ASSERT_EQ(splitUp.getX(0), 6);
701     ASSERT_EQ(splitUp.getY(0), 6);
702 }
703 
TEST_F(MotionEventTest,SplitPointerMove)704 TEST_F(MotionEventTest, SplitPointerMove) {
705     MotionEvent event = MotionEventBuilder(AMOTION_EVENT_ACTION_MOVE, AINPUT_SOURCE_TOUCHSCREEN)
706                                 .downTime(ARBITRARY_DOWN_TIME)
707                                 .pointer(PointerBuilder(/*id=*/4, ToolType::FINGER).x(4).y(4))
708                                 .pointer(PointerBuilder(/*id=*/6, ToolType::FINGER).x(6).y(6))
709                                 .pointer(PointerBuilder(/*id=*/8, ToolType::FINGER).x(8).y(8))
710                                 .transform(ui::Transform(ui::Transform::ROT_90, 100, 100))
711                                 .rawTransform(ui::Transform(ui::Transform::FLIP_H, 50, 50))
712                                 .build();
713 
714     MotionEvent splitMove;
715     std::bitset<MAX_POINTER_ID + 1> splitMoveIds{};
716     splitMoveIds.set(4, true);
717     splitMoveIds.set(8, true);
718     splitMove.splitFrom(event, splitMoveIds, /*eventId=*/42);
719     ASSERT_EQ(splitMove.getAction(), AMOTION_EVENT_ACTION_MOVE);
720     ASSERT_EQ(splitMove.getPointerCount(), 2u);
721     ASSERT_EQ(splitMove.getPointerId(0), 4);
722     ASSERT_EQ(splitMove.getX(0), event.getX(0));
723     ASSERT_EQ(splitMove.getY(0), event.getY(0));
724     ASSERT_EQ(splitMove.getRawX(0), event.getRawX(0));
725     ASSERT_EQ(splitMove.getRawY(0), event.getRawY(0));
726     ASSERT_EQ(splitMove.getPointerId(1), 8);
727     ASSERT_EQ(splitMove.getX(1), event.getX(2));
728     ASSERT_EQ(splitMove.getY(1), event.getY(2));
729     ASSERT_EQ(splitMove.getRawX(1), event.getRawX(2));
730     ASSERT_EQ(splitMove.getRawY(1), event.getRawY(2));
731 }
732 
TEST_F(MotionEventTest,OffsetLocation)733 TEST_F(MotionEventTest, OffsetLocation) {
734     MotionEvent event;
735     initializeEventWithHistory(&event);
736     const float xOffset = event.getRawXOffset();
737     const float yOffset = event.getRawYOffset();
738 
739     event.offsetLocation(5.0f, -2.0f);
740 
741     ASSERT_EQ(xOffset + 5.0f, event.getRawXOffset());
742     ASSERT_EQ(yOffset - 2.0f, event.getRawYOffset());
743 }
744 
TEST_F(MotionEventTest,Scale)745 TEST_F(MotionEventTest, Scale) {
746     MotionEvent event;
747     initializeEventWithHistory(&event);
748     const float unscaledOrientation = event.getOrientation(0);
749     const float unscaledXOffset = event.getRawXOffset();
750     const float unscaledYOffset = event.getRawYOffset();
751 
752     event.scale(2.0f);
753 
754     ASSERT_EQ(unscaledXOffset * 2, event.getRawXOffset());
755     ASSERT_EQ(unscaledYOffset * 2, event.getRawYOffset());
756 
757     ASSERT_NEAR((RAW_X_OFFSET + 210 * RAW_X_SCALE) * 2, event.getRawX(0), EPSILON);
758     ASSERT_NEAR((RAW_Y_OFFSET + 211 * RAW_Y_SCALE) * 2, event.getRawY(0), EPSILON);
759     ASSERT_NEAR((X_OFFSET + 210 * X_SCALE) * 2, event.getX(0), EPSILON);
760     ASSERT_NEAR((Y_OFFSET + 211 * Y_SCALE) * 2, event.getY(0), EPSILON);
761     ASSERT_EQ(212, event.getPressure(0));
762     ASSERT_EQ(213, event.getSize(0));
763     ASSERT_EQ(214 * 2, event.getTouchMajor(0));
764     ASSERT_EQ(215 * 2, event.getTouchMinor(0));
765     ASSERT_EQ(216 * 2, event.getToolMajor(0));
766     ASSERT_EQ(217 * 2, event.getToolMinor(0));
767     ASSERT_EQ(unscaledOrientation, event.getOrientation(0));
768 }
769 
TEST_F(MotionEventTest,Parcel)770 TEST_F(MotionEventTest, Parcel) {
771     Parcel parcel;
772 
773     MotionEvent inEvent;
774     initializeEventWithHistory(&inEvent);
775     MotionEvent outEvent;
776 
777     // Round trip.
778     inEvent.writeToParcel(&parcel);
779     parcel.setDataPosition(0);
780     outEvent.readFromParcel(&parcel);
781 
782     ASSERT_NO_FATAL_FAILURE(assertEqualsEventWithHistory(&outEvent));
783 }
784 
setRotationMatrix(std::array<float,9> & matrix,float angle)785 static void setRotationMatrix(std::array<float, 9>& matrix, float angle) {
786     float sin = sinf(angle);
787     float cos = cosf(angle);
788     matrix[0] = cos;
789     matrix[1] = -sin;
790     matrix[2] = 0;
791     matrix[3] = sin;
792     matrix[4] = cos;
793     matrix[5] = 0;
794     matrix[6] = 0;
795     matrix[7] = 0;
796     matrix[8] = 1.0f;
797 }
798 
TEST_F(MotionEventTest,Transform)799 TEST_F(MotionEventTest, Transform) {
800     // Generate some points on a circle.
801     // Each point 'i' is a point on a circle of radius ROTATION centered at (3,2) at an angle
802     // of ARC * i degrees clockwise relative to the Y axis.
803     // The geometrical representation is irrelevant to the test, it's just easy to generate
804     // and check rotation.  We set the orientation to the same angle.
805     // Coordinate system: down is increasing Y, right is increasing X.
806     static constexpr float PI_180 = float(M_PI / 180);
807     static constexpr float RADIUS = 10;
808     static constexpr float ARC = 36;
809     static constexpr float ROTATION = ARC * 2;
810 
811     const size_t pointerCount = 11;
812     PointerProperties pointerProperties[pointerCount];
813     PointerCoords pointerCoords[pointerCount];
814     for (size_t i = 0; i < pointerCount; i++) {
815         float angle = float(i * ARC * PI_180);
816         pointerProperties[i].clear();
817         pointerProperties[i].id = i;
818         pointerCoords[i].clear();
819         pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_X, sinf(angle) * RADIUS + 3);
820         pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_Y, -cosf(angle) * RADIUS + 2);
821         pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, angle);
822     }
823     MotionEvent event;
824     ui::Transform identityTransform;
825     const int32_t flags = AMOTION_EVENT_PRIVATE_FLAG_SUPPORTS_ORIENTATION |
826             AMOTION_EVENT_PRIVATE_FLAG_SUPPORTS_DIRECTIONAL_ORIENTATION;
827     event.initialize(InputEvent::nextId(), /*deviceId=*/0, AINPUT_SOURCE_TOUCHSCREEN, DISPLAY_ID,
828                      INVALID_HMAC, AMOTION_EVENT_ACTION_MOVE, /*actionButton=*/0, flags,
829                      AMOTION_EVENT_EDGE_FLAG_NONE, AMETA_NONE, /*buttonState=*/0,
830                      MotionClassification::NONE, identityTransform, /*xPrecision=*/0,
831                      /*yPrecision=*/0, /*xCursorPosition=*/3 + RADIUS, /*yCursorPosition=*/2,
832                      identityTransform, /*downTime=*/0, /*eventTime=*/0, pointerCount,
833                      pointerProperties, pointerCoords);
834     float originalRawX = 0 + 3;
835     float originalRawY = -RADIUS + 2;
836 
837     // Check original raw X and Y assumption.
838     ASSERT_NEAR(originalRawX, event.getRawX(0), 0.001);
839     ASSERT_NEAR(originalRawY, event.getRawY(0), 0.001);
840 
841     // Now translate the motion event so the circle's origin is at (0,0).
842     event.offsetLocation(-3, -2);
843 
844     // Offsetting the location should preserve the raw X and Y of the first point.
845     ASSERT_NEAR(originalRawX, event.getRawX(0), 0.001);
846     ASSERT_NEAR(originalRawY, event.getRawY(0), 0.001);
847 
848     // Apply a rotation about the origin by ROTATION degrees clockwise.
849     std::array<float, 9> matrix;
850     setRotationMatrix(matrix, ROTATION * PI_180);
851     event.transform(matrix);
852 
853     // Check the points.
854     for (size_t i = 0; i < pointerCount; i++) {
855         float angle = float((i * ARC + ROTATION) * PI_180);
856         ASSERT_NEAR(sinf(angle) * RADIUS, event.getX(i), 0.001);
857         ASSERT_NEAR(-cosf(angle) * RADIUS, event.getY(i), 0.001);
858         ASSERT_NEAR(tanf(angle), tanf(event.getOrientation(i)), 0.1);
859     }
860 
861     // Check cursor positions. The original cursor position is at (3 + RADIUS, 2), where the center
862     // of the circle is (3, 2), so the cursor position is to the right of the center of the circle.
863     // The choice of triangular functions in this test defines the angle of rotation clockwise
864     // relative to the y-axis. Therefore the cursor position's angle is 90 degrees. Here we swap the
865     // triangular function so that we don't have to add the 90 degrees.
866     ASSERT_NEAR(cosf(PI_180 * ROTATION) * RADIUS, event.getXCursorPosition(), 0.001);
867     ASSERT_NEAR(sinf(PI_180 * ROTATION) * RADIUS, event.getYCursorPosition(), 0.001);
868 
869     // Applying the transformation should preserve the raw X and Y of the first point.
870     ASSERT_NEAR(originalRawX, event.getRawX(0), 0.001);
871     ASSERT_NEAR(originalRawY, event.getRawY(0), 0.001);
872 }
873 
createMotionEvent(int32_t source,uint32_t action,float x,float y,float dx,float dy,const ui::Transform & transform,const ui::Transform & rawTransform)874 MotionEvent createMotionEvent(int32_t source, uint32_t action, float x, float y, float dx, float dy,
875                               const ui::Transform& transform, const ui::Transform& rawTransform) {
876     std::vector<PointerProperties> pointerProperties;
877     pointerProperties.push_back(PointerProperties{/*id=*/0, ToolType::FINGER});
878     std::vector<PointerCoords> pointerCoords;
879     pointerCoords.emplace_back().clear();
880     pointerCoords.back().setAxisValue(AMOTION_EVENT_AXIS_X, x);
881     pointerCoords.back().setAxisValue(AMOTION_EVENT_AXIS_Y, y);
882     pointerCoords.back().setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, dx);
883     pointerCoords.back().setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, dy);
884     nsecs_t eventTime = systemTime(SYSTEM_TIME_MONOTONIC);
885     MotionEvent event;
886     event.initialize(InputEvent::nextId(), /*deviceId=*/1, source, ui::LogicalDisplayId::DEFAULT,
887                      INVALID_HMAC, action, /*actionButton=*/0, /*flags=*/0, /*edgeFlags=*/0,
888                      AMETA_NONE, /*buttonState=*/0, MotionClassification::NONE, transform,
889                      /*xPrecision=*/0, /*yPrecision=*/0, AMOTION_EVENT_INVALID_CURSOR_POSITION,
890                      AMOTION_EVENT_INVALID_CURSOR_POSITION, rawTransform, eventTime, eventTime,
891                      pointerCoords.size(), pointerProperties.data(), pointerCoords.data());
892     return event;
893 }
894 
createTouchDownEvent(float x,float y,float dx,float dy,const ui::Transform & transform,const ui::Transform & rawTransform)895 MotionEvent createTouchDownEvent(float x, float y, float dx, float dy,
896                                  const ui::Transform& transform,
897                                  const ui::Transform& rawTransform) {
898     return createMotionEvent(AINPUT_SOURCE_TOUCHSCREEN, AMOTION_EVENT_ACTION_DOWN, x, y, dx, dy,
899                              transform, rawTransform);
900 }
901 
TEST_F(MotionEventTest,ApplyTransform)902 TEST_F(MotionEventTest, ApplyTransform) {
903     // Create a rotate-90 transform with an offset (like a window which isn't fullscreen).
904     ui::Transform identity;
905     ui::Transform transform(ui::Transform::ROT_90, 800, 400);
906     transform.set(transform.tx() + 20, transform.ty() + 40);
907     ui::Transform rawTransform(ui::Transform::ROT_90, 800, 400);
908     MotionEvent event = createTouchDownEvent(60, 100, 42, 96, transform, rawTransform);
909     ASSERT_EQ(700, event.getRawX(0));
910     ASSERT_EQ(60, event.getRawY(0));
911     ASSERT_NE(event.getRawX(0), event.getX(0));
912     ASSERT_NE(event.getRawY(0), event.getY(0));
913     // Relative values should be rotated but not translated.
914     ASSERT_EQ(-96, event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, 0));
915     ASSERT_EQ(42, event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, 0));
916 
917     MotionEvent changedEvent = createTouchDownEvent(60, 100, 42, 96, identity, identity);
918     const std::array<float, 9> rowMajor{transform[0][0], transform[1][0], transform[2][0],
919                                         transform[0][1], transform[1][1], transform[2][1],
920                                         transform[0][2], transform[1][2], transform[2][2]};
921     changedEvent.applyTransform(rowMajor);
922 
923     // transformContent effectively rotates the raw coordinates, so those should now include
924     // both rotation AND offset.
925     ASSERT_EQ(720, changedEvent.getRawX(0));
926     ASSERT_EQ(100, changedEvent.getRawY(0));
927     // Relative values should be rotated but not translated.
928     ASSERT_EQ(-96, event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, 0));
929     ASSERT_EQ(42, event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, 0));
930 
931     // The transformed output should be the same then.
932     ASSERT_NEAR(event.getX(0), changedEvent.getX(0), 0.001);
933     ASSERT_NEAR(event.getY(0), changedEvent.getY(0), 0.001);
934     ASSERT_NEAR(event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, 0),
935                 changedEvent.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, 0), 0.001);
936     ASSERT_NEAR(event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, 0),
937                 changedEvent.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, 0), 0.001);
938 }
939 
TEST_F(MotionEventTest,JoystickAndTouchpadAreNotTransformed)940 TEST_F(MotionEventTest, JoystickAndTouchpadAreNotTransformed) {
941     constexpr static std::array kNonTransformedSources =
942             {std::pair(AINPUT_SOURCE_TOUCHPAD, AMOTION_EVENT_ACTION_DOWN),
943              std::pair(AINPUT_SOURCE_JOYSTICK, AMOTION_EVENT_ACTION_MOVE),
944              std::pair(AINPUT_SOURCE_MOUSE_RELATIVE, AMOTION_EVENT_ACTION_MOVE)};
945     // Create a rotate-90 transform with an offset (like a window which isn't fullscreen).
946     ui::Transform transform(ui::Transform::ROT_90, 800, 400);
947     transform.set(transform.tx() + 20, transform.ty() + 40);
948 
949     for (const auto& [source, action] : kNonTransformedSources) {
950         const MotionEvent event =
951                 createMotionEvent(source, action, 60, 100, 0, 0, transform, transform);
952 
953         // These events should not be transformed in any way.
954         ASSERT_EQ(60, event.getX(0));
955         ASSERT_EQ(100, event.getY(0));
956         ASSERT_EQ(event.getRawX(0), event.getX(0));
957         ASSERT_EQ(event.getRawY(0), event.getY(0));
958     }
959 }
960 
TEST_F(MotionEventTest,NonPointerSourcesAreNotTranslated)961 TEST_F(MotionEventTest, NonPointerSourcesAreNotTranslated) {
962     constexpr static std::array kNonPointerSources = {std::pair(AINPUT_SOURCE_TRACKBALL,
963                                                                 AMOTION_EVENT_ACTION_DOWN),
964                                                       std::pair(AINPUT_SOURCE_TOUCH_NAVIGATION,
965                                                                 AMOTION_EVENT_ACTION_MOVE)};
966     // Create a rotate-90 transform with an offset (like a window which isn't fullscreen).
967     ui::Transform transform(ui::Transform::ROT_90, 800, 400);
968     transform.set(transform.tx() + 20, transform.ty() + 40);
969 
970     for (const auto& [source, action] : kNonPointerSources) {
971         const MotionEvent event =
972                 createMotionEvent(source, action, 60, 100, 42, 96, transform, transform);
973 
974         // Since this event comes from a non-pointer source, it should include rotation but not
975         // translation/offset.
976         ASSERT_EQ(-100, event.getX(0));
977         ASSERT_EQ(60, event.getY(0));
978         ASSERT_EQ(event.getRawX(0), event.getX(0));
979         ASSERT_EQ(event.getRawY(0), event.getY(0));
980     }
981 }
982 
TEST_F(MotionEventTest,AxesAreCorrectlyTransformed)983 TEST_F(MotionEventTest, AxesAreCorrectlyTransformed) {
984     const ui::Transform identity;
985     ui::Transform transform;
986     transform.set({1.1, -2.2, 3.3, -4.4, 5.5, -6.6, 0, 0, 1});
987     ui::Transform rawTransform;
988     rawTransform.set({-6.6, 5.5, -4.4, 3.3, -2.2, 1.1, 0, 0, 1});
989     auto transformWithoutTranslation = [](const ui::Transform& t, float x, float y) {
990         auto newPoint = t.transform(x, y);
991         auto newOrigin = t.transform(0, 0);
992         return newPoint - newOrigin;
993     };
994 
995     const MotionEvent event = createTouchDownEvent(60, 100, 42, 96, transform, rawTransform);
996 
997     // The x and y axes should have the window transform applied.
998     const auto newPoint = transform.transform(60, 100);
999     ASSERT_NEAR(newPoint.x, event.getX(0), EPSILON);
1000     ASSERT_NEAR(newPoint.y, event.getY(0), EPSILON);
1001 
1002     // The raw values should have the display transform applied.
1003     const auto raw = rawTransform.transform(60, 100);
1004     ASSERT_NEAR(raw.x, event.getRawX(0), EPSILON);
1005     ASSERT_NEAR(raw.y, event.getRawY(0), EPSILON);
1006 
1007     // Relative values should have the window transform applied without any translation.
1008     const auto rel = transformWithoutTranslation(transform, 42, 96);
1009     ASSERT_NEAR(rel.x, event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, 0), EPSILON);
1010     ASSERT_NEAR(rel.y, event.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, 0), EPSILON);
1011 }
1012 
TEST_F(MotionEventTest,Initialize_SetsClassification)1013 TEST_F(MotionEventTest, Initialize_SetsClassification) {
1014     std::array<MotionClassification, 3> classifications = {
1015             MotionClassification::NONE,
1016             MotionClassification::AMBIGUOUS_GESTURE,
1017             MotionClassification::DEEP_PRESS,
1018     };
1019 
1020     MotionEvent event;
1021     constexpr size_t pointerCount = 1;
1022     PointerProperties pointerProperties[pointerCount];
1023     PointerCoords pointerCoords[pointerCount];
1024     for (size_t i = 0; i < pointerCount; i++) {
1025         pointerProperties[i].clear();
1026         pointerProperties[i].id = i;
1027         pointerCoords[i].clear();
1028     }
1029 
1030     ui::Transform identityTransform;
1031     for (MotionClassification classification : classifications) {
1032         event.initialize(InputEvent::nextId(), /*deviceId=*/0, AINPUT_SOURCE_TOUCHSCREEN,
1033                          DISPLAY_ID, INVALID_HMAC, AMOTION_EVENT_ACTION_DOWN, 0, 0,
1034                          AMOTION_EVENT_EDGE_FLAG_NONE, AMETA_NONE, 0, classification,
1035                          identityTransform, 0, 0, AMOTION_EVENT_INVALID_CURSOR_POSITION,
1036                          AMOTION_EVENT_INVALID_CURSOR_POSITION, identityTransform, /*downTime=*/0,
1037                          /*eventTime=*/0, pointerCount, pointerProperties, pointerCoords);
1038         ASSERT_EQ(classification, event.getClassification());
1039     }
1040 }
1041 
TEST_F(MotionEventTest,Initialize_SetsCursorPosition)1042 TEST_F(MotionEventTest, Initialize_SetsCursorPosition) {
1043     MotionEvent event;
1044     constexpr size_t pointerCount = 1;
1045     PointerProperties pointerProperties[pointerCount];
1046     PointerCoords pointerCoords[pointerCount];
1047     for (size_t i = 0; i < pointerCount; i++) {
1048         pointerProperties[i].clear();
1049         pointerProperties[i].id = i;
1050         pointerCoords[i].clear();
1051     }
1052 
1053     ui::Transform identityTransform;
1054     event.initialize(InputEvent::nextId(), /*deviceId=*/0, AINPUT_SOURCE_MOUSE, DISPLAY_ID,
1055                      INVALID_HMAC, AMOTION_EVENT_ACTION_DOWN, 0, 0, AMOTION_EVENT_EDGE_FLAG_NONE,
1056                      AMETA_NONE, 0, MotionClassification::NONE, identityTransform, 0, 0,
1057                      /*xCursorPosition=*/280, /*yCursorPosition=*/540, identityTransform,
1058                      /*downTime=*/0, /*eventTime=*/0, pointerCount, pointerProperties,
1059                      pointerCoords);
1060     event.offsetLocation(20, 60);
1061     ASSERT_EQ(280, event.getRawXCursorPosition());
1062     ASSERT_EQ(540, event.getRawYCursorPosition());
1063     ASSERT_EQ(300, event.getXCursorPosition());
1064     ASSERT_EQ(600, event.getYCursorPosition());
1065 }
1066 
TEST_F(MotionEventTest,SetCursorPosition)1067 TEST_F(MotionEventTest, SetCursorPosition) {
1068     MotionEvent event;
1069     initializeEventWithHistory(&event);
1070     event.setSource(AINPUT_SOURCE_MOUSE);
1071 
1072     event.setCursorPosition(3, 4);
1073     ASSERT_EQ(3, event.getXCursorPosition());
1074     ASSERT_EQ(4, event.getYCursorPosition());
1075 }
1076 
TEST_F(MotionEventTest,CoordinatesAreRoundedAppropriately)1077 TEST_F(MotionEventTest, CoordinatesAreRoundedAppropriately) {
1078     // These are specifically integral values, since we are testing for rounding.
1079     const vec2 EXPECTED{400.f, 700.f};
1080 
1081     // Pick a transform such that transforming the point with its inverse and bringing that
1082     // back to the original coordinate space results in a non-zero error amount due to the
1083     // nature of floating point arithmetics. This can happen when the display is scaled.
1084     // For example, the 'adb shell wm size' command can be used to set an override for the
1085     // logical display size, which could result in the display being scaled.
1086     constexpr float scale = 720.f / 1080.f;
1087     ui::Transform transform;
1088     transform.set(scale, 0, 0, scale);
1089     ASSERT_NE(EXPECTED, transform.transform(transform.inverse().transform(EXPECTED)));
1090 
1091     // Store the inverse-transformed values in the motion event.
1092     const vec2 rawCoords = transform.inverse().transform(EXPECTED);
1093     PointerCoords pc{};
1094     pc.setAxisValue(AMOTION_EVENT_AXIS_X, rawCoords.x);
1095     pc.setAxisValue(AMOTION_EVENT_AXIS_Y, rawCoords.y);
1096     PointerProperties pp{};
1097     MotionEvent event;
1098     event.initialize(InputEvent::nextId(), 2, AINPUT_SOURCE_TOUCHSCREEN, DISPLAY_ID, HMAC,
1099                      AMOTION_EVENT_ACTION_MOVE, 0, AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED,
1100                      AMOTION_EVENT_EDGE_FLAG_TOP, AMETA_ALT_ON, AMOTION_EVENT_BUTTON_PRIMARY,
1101                      MotionClassification::NONE, transform, 2.0f, 2.1f, rawCoords.x, rawCoords.y,
1102                      transform, ARBITRARY_DOWN_TIME, ARBITRARY_EVENT_TIME, 1, &pp, &pc);
1103 
1104     // When using the getters from the MotionEvent to obtain the coordinates, the transformed
1105     // values should be rounded by an appropriate amount so that they now precisely equal the
1106     // original coordinates.
1107     ASSERT_EQ(EXPECTED.x, event.getX(0));
1108     ASSERT_EQ(EXPECTED.y, event.getY(0));
1109     ASSERT_EQ(EXPECTED.x, event.getRawX(0));
1110     ASSERT_EQ(EXPECTED.y, event.getRawY(0));
1111     ASSERT_EQ(EXPECTED.x, event.getXCursorPosition());
1112     ASSERT_EQ(EXPECTED.y, event.getYCursorPosition());
1113 }
1114 
TEST_F(MotionEventTest,InvalidOrientationNotRotated)1115 TEST_F(MotionEventTest, InvalidOrientationNotRotated) {
1116     // This touch event does not have a value for AXIS_ORIENTATION, and the flags are implicitly
1117     // set to 0. The transform is set to a 90-degree rotation.
1118     MotionEvent event = MotionEventBuilder(AMOTION_EVENT_ACTION_MOVE, AINPUT_SOURCE_TOUCHSCREEN)
1119                                 .downTime(ARBITRARY_DOWN_TIME)
1120                                 .pointer(PointerBuilder(/*id=*/4, ToolType::FINGER).x(4).y(4))
1121                                 .transform(ui::Transform(ui::Transform::ROT_90, 100, 100))
1122                                 .rawTransform(ui::Transform(ui::Transform::FLIP_H, 50, 50))
1123                                 .build();
1124     ASSERT_EQ(event.getOrientation(/*pointerIndex=*/0), 0.f);
1125     event.transform(asFloat9(ui::Transform(ui::Transform::ROT_90, 100, 100)));
1126     ASSERT_EQ(event.getOrientation(/*pointerIndex=*/0), 0.f);
1127     event.transform(asFloat9(ui::Transform(ui::Transform::ROT_180, 100, 100)));
1128     ASSERT_EQ(event.getOrientation(/*pointerIndex=*/0), 0.f);
1129     event.applyTransform(asFloat9(ui::Transform(ui::Transform::ROT_270, 100, 100)));
1130     ASSERT_EQ(event.getOrientation(/*pointerIndex=*/0), 0.f);
1131 }
1132 
TEST_F(MotionEventTest,ValidZeroOrientationRotated)1133 TEST_F(MotionEventTest, ValidZeroOrientationRotated) {
1134     // This touch events will implicitly have a value of 0 for its AXIS_ORIENTATION.
1135     auto builder = MotionEventBuilder(AMOTION_EVENT_ACTION_MOVE, AINPUT_SOURCE_TOUCHSCREEN)
1136                            .downTime(ARBITRARY_DOWN_TIME)
1137                            .pointer(PointerBuilder(/*id=*/4, ToolType::FINGER).x(4).y(4))
1138                            .transform(ui::Transform(ui::Transform::ROT_90, 100, 100))
1139                            .rawTransform(ui::Transform(ui::Transform::FLIP_H, 50, 50))
1140                            .addFlag(AMOTION_EVENT_PRIVATE_FLAG_SUPPORTS_ORIENTATION);
1141     MotionEvent nonDirectionalEvent = builder.build();
1142     MotionEvent directionalEvent =
1143             builder.addFlag(AMOTION_EVENT_PRIVATE_FLAG_SUPPORTS_DIRECTIONAL_ORIENTATION).build();
1144 
1145     // The angle is rotated by the initial transform, a 90-degree rotation.
1146     ASSERT_NEAR(fabs(nonDirectionalEvent.getOrientation(/*pointerIndex=*/0)), M_PI_2, EPSILON);
1147     ASSERT_NEAR(directionalEvent.getOrientation(/*pointerIndex=*/0), M_PI_2, EPSILON);
1148 
1149     nonDirectionalEvent.transform(asFloat9(ui::Transform(ui::Transform::ROT_90, 100, 100)));
1150     directionalEvent.transform(asFloat9(ui::Transform(ui::Transform::ROT_90, 100, 100)));
1151     ASSERT_NEAR(nonDirectionalEvent.getOrientation(/*pointerIndex=*/0), 0.f, EPSILON);
1152     ASSERT_NEAR(fabs(directionalEvent.getOrientation(/*pointerIndex=*/0)), M_PI, EPSILON);
1153 
1154     nonDirectionalEvent.transform(asFloat9(ui::Transform(ui::Transform::ROT_180, 100, 100)));
1155     directionalEvent.transform(asFloat9(ui::Transform(ui::Transform::ROT_180, 100, 100)));
1156     ASSERT_NEAR(nonDirectionalEvent.getOrientation(/*pointerIndex=*/0), 0.f, EPSILON);
1157     ASSERT_NEAR(directionalEvent.getOrientation(/*pointerIndex=*/0), 0.f, EPSILON);
1158 
1159     nonDirectionalEvent.applyTransform(asFloat9(ui::Transform(ui::Transform::ROT_270, 100, 100)));
1160     directionalEvent.applyTransform(asFloat9(ui::Transform(ui::Transform::ROT_270, 100, 100)));
1161     ASSERT_NEAR(fabs(nonDirectionalEvent.getOrientation(/*pointerIndex=*/0)), M_PI_2, EPSILON);
1162     ASSERT_NEAR(directionalEvent.getOrientation(/*pointerIndex=*/0), -M_PI_2, EPSILON);
1163 }
1164 
TEST_F(MotionEventTest,ValidNonZeroOrientationRotated)1165 TEST_F(MotionEventTest, ValidNonZeroOrientationRotated) {
1166     const float initial = 1.f;
1167     auto builder = MotionEventBuilder(AMOTION_EVENT_ACTION_MOVE, AINPUT_SOURCE_TOUCHSCREEN)
1168                            .downTime(ARBITRARY_DOWN_TIME)
1169                            .pointer(PointerBuilder(/*id=*/4, ToolType::FINGER)
1170                                             .x(4)
1171                                             .y(4)
1172                                             .axis(AMOTION_EVENT_AXIS_ORIENTATION, initial))
1173                            .transform(ui::Transform(ui::Transform::ROT_90, 100, 100))
1174                            .rawTransform(ui::Transform(ui::Transform::FLIP_H, 50, 50))
1175                            .addFlag(AMOTION_EVENT_PRIVATE_FLAG_SUPPORTS_ORIENTATION);
1176 
1177     MotionEvent nonDirectionalEvent = builder.build();
1178     MotionEvent directionalEvent =
1179             builder.addFlag(AMOTION_EVENT_PRIVATE_FLAG_SUPPORTS_DIRECTIONAL_ORIENTATION).build();
1180 
1181     // The angle is rotated by the initial transform, a 90-degree rotation.
1182     ASSERT_NEAR(nonDirectionalEvent.getOrientation(/*pointerIndex=*/0), initial - M_PI_2, EPSILON);
1183     ASSERT_NEAR(directionalEvent.getOrientation(/*pointerIndex=*/0), initial + M_PI_2, EPSILON);
1184 
1185     nonDirectionalEvent.transform(asFloat9(ui::Transform(ui::Transform::ROT_90, 100, 100)));
1186     directionalEvent.transform(asFloat9(ui::Transform(ui::Transform::ROT_90, 100, 100)));
1187     ASSERT_NEAR(nonDirectionalEvent.getOrientation(/*pointerIndex=*/0), initial, EPSILON);
1188     ASSERT_NEAR(directionalEvent.getOrientation(/*pointerIndex=*/0), initial - M_PI, EPSILON);
1189 
1190     nonDirectionalEvent.transform(asFloat9(ui::Transform(ui::Transform::ROT_180, 100, 100)));
1191     directionalEvent.transform(asFloat9(ui::Transform(ui::Transform::ROT_180, 100, 100)));
1192     ASSERT_NEAR(nonDirectionalEvent.getOrientation(/*pointerIndex=*/0), initial, EPSILON);
1193     ASSERT_NEAR(directionalEvent.getOrientation(/*pointerIndex=*/0), initial, EPSILON);
1194 
1195     nonDirectionalEvent.applyTransform(asFloat9(ui::Transform(ui::Transform::ROT_270, 100, 100)));
1196     directionalEvent.applyTransform(asFloat9(ui::Transform(ui::Transform::ROT_270, 100, 100)));
1197     ASSERT_NEAR(nonDirectionalEvent.getOrientation(/*pointerIndex=*/0), initial - M_PI_2, EPSILON);
1198     ASSERT_NEAR(directionalEvent.getOrientation(/*pointerIndex=*/0), initial - M_PI_2, EPSILON);
1199 }
1200 
1201 } // namespace android
1202