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 <binder/Parcel.h> 21 #include <gtest/gtest.h> 22 #include <input/Input.h> 23 24 namespace android { 25 26 // Default display id. 27 static constexpr int32_t DISPLAY_ID = ADISPLAY_ID_DEFAULT; 28 29 class BaseTest : public testing::Test { }; 30 31 // --- PointerCoordsTest --- 32 33 class PointerCoordsTest : public BaseTest { 34 }; 35 36 TEST_F(PointerCoordsTest, ClearSetsBitsToZero) { 37 PointerCoords coords; 38 coords.clear(); 39 40 ASSERT_EQ(0ULL, coords.bits); 41 } 42 43 TEST_F(PointerCoordsTest, AxisValues) { 44 float* valuePtr; 45 PointerCoords coords; 46 coords.clear(); 47 48 // Check invariants when no axes are present. 49 ASSERT_EQ(0, coords.getAxisValue(0)) 50 << "getAxisValue should return zero because axis is not present"; 51 ASSERT_EQ(0, coords.getAxisValue(1)) 52 << "getAxisValue should return zero because axis is not present"; 53 54 // Set first axis. 55 ASSERT_EQ(OK, coords.setAxisValue(1, 5)); 56 ASSERT_EQ(5, coords.values[0]); 57 ASSERT_EQ(0x4000000000000000ULL, coords.bits); 58 59 ASSERT_EQ(0, coords.getAxisValue(0)) 60 << "getAxisValue should return zero because axis is not present"; 61 ASSERT_EQ(5, coords.getAxisValue(1)) 62 << "getAxisValue should return value of axis"; 63 64 // Set an axis with a higher id than all others. (appending value at the end) 65 ASSERT_EQ(OK, coords.setAxisValue(3, 2)); 66 ASSERT_EQ(0x5000000000000000ULL, coords.bits); 67 ASSERT_EQ(5, coords.values[0]); 68 ASSERT_EQ(2, coords.values[1]); 69 70 ASSERT_EQ(0, coords.getAxisValue(0)) 71 << "getAxisValue should return zero because axis is not present"; 72 ASSERT_EQ(5, coords.getAxisValue(1)) 73 << "getAxisValue should return value of axis"; 74 ASSERT_EQ(0, coords.getAxisValue(2)) 75 << "getAxisValue should return zero because axis is not present"; 76 ASSERT_EQ(2, coords.getAxisValue(3)) 77 << "getAxisValue should return value of axis"; 78 79 // Set an axis with an id lower than all others. (prepending value at beginning) 80 ASSERT_EQ(OK, coords.setAxisValue(0, 4)); 81 ASSERT_EQ(0xd000000000000000ULL, coords.bits); 82 ASSERT_EQ(4, coords.values[0]); 83 ASSERT_EQ(5, coords.values[1]); 84 ASSERT_EQ(2, coords.values[2]); 85 86 ASSERT_EQ(4, coords.getAxisValue(0)) 87 << "getAxisValue should return value of axis"; 88 ASSERT_EQ(5, coords.getAxisValue(1)) 89 << "getAxisValue should return value of axis"; 90 ASSERT_EQ(0, coords.getAxisValue(2)) 91 << "getAxisValue should return zero because axis is not present"; 92 ASSERT_EQ(2, coords.getAxisValue(3)) 93 << "getAxisValue should return value of axis"; 94 95 // Set an axis with an id between the others. (inserting value in the middle) 96 ASSERT_EQ(OK, coords.setAxisValue(2, 1)); 97 ASSERT_EQ(0xf000000000000000ULL, coords.bits); 98 ASSERT_EQ(4, coords.values[0]); 99 ASSERT_EQ(5, coords.values[1]); 100 ASSERT_EQ(1, coords.values[2]); 101 ASSERT_EQ(2, coords.values[3]); 102 103 ASSERT_EQ(4, coords.getAxisValue(0)) 104 << "getAxisValue should return value of axis"; 105 ASSERT_EQ(5, coords.getAxisValue(1)) 106 << "getAxisValue should return value of axis"; 107 ASSERT_EQ(1, coords.getAxisValue(2)) 108 << "getAxisValue should return value of axis"; 109 ASSERT_EQ(2, coords.getAxisValue(3)) 110 << "getAxisValue should return value of axis"; 111 112 // Set an existing axis value in place. 113 ASSERT_EQ(OK, coords.setAxisValue(1, 6)); 114 ASSERT_EQ(0xf000000000000000ULL, coords.bits); 115 ASSERT_EQ(4, coords.values[0]); 116 ASSERT_EQ(6, coords.values[1]); 117 ASSERT_EQ(1, coords.values[2]); 118 ASSERT_EQ(2, coords.values[3]); 119 120 ASSERT_EQ(4, coords.getAxisValue(0)) 121 << "getAxisValue should return value of axis"; 122 ASSERT_EQ(6, coords.getAxisValue(1)) 123 << "getAxisValue should return value of axis"; 124 ASSERT_EQ(1, coords.getAxisValue(2)) 125 << "getAxisValue should return value of axis"; 126 ASSERT_EQ(2, coords.getAxisValue(3)) 127 << "getAxisValue should return value of axis"; 128 129 // Set maximum number of axes. 130 for (size_t axis = 4; axis < PointerCoords::MAX_AXES; axis++) { 131 ASSERT_EQ(OK, coords.setAxisValue(axis, axis)); 132 } 133 ASSERT_EQ(PointerCoords::MAX_AXES, __builtin_popcountll(coords.bits)); 134 135 // Try to set one more axis beyond maximum number. 136 // Ensure bits are unchanged. 137 ASSERT_EQ(NO_MEMORY, coords.setAxisValue(PointerCoords::MAX_AXES, 100)); 138 ASSERT_EQ(PointerCoords::MAX_AXES, __builtin_popcountll(coords.bits)); 139 } 140 141 TEST_F(PointerCoordsTest, Parcel) { 142 Parcel parcel; 143 144 PointerCoords inCoords; 145 inCoords.clear(); 146 PointerCoords outCoords; 147 148 // Round trip with empty coords. 149 inCoords.writeToParcel(&parcel); 150 parcel.setDataPosition(0); 151 outCoords.readFromParcel(&parcel); 152 153 ASSERT_EQ(0ULL, outCoords.bits); 154 155 // Round trip with some values. 156 parcel.freeData(); 157 inCoords.setAxisValue(2, 5); 158 inCoords.setAxisValue(5, 8); 159 160 inCoords.writeToParcel(&parcel); 161 parcel.setDataPosition(0); 162 outCoords.readFromParcel(&parcel); 163 164 ASSERT_EQ(outCoords.bits, inCoords.bits); 165 ASSERT_EQ(outCoords.values[0], inCoords.values[0]); 166 ASSERT_EQ(outCoords.values[1], inCoords.values[1]); 167 } 168 169 170 // --- KeyEventTest --- 171 172 class KeyEventTest : public BaseTest { 173 }; 174 175 TEST_F(KeyEventTest, Properties) { 176 KeyEvent event; 177 178 // Initialize and get properties. 179 const nsecs_t ARBITRARY_DOWN_TIME = 1; 180 const nsecs_t ARBITRARY_EVENT_TIME = 2; 181 event.initialize(2, AINPUT_SOURCE_GAMEPAD, DISPLAY_ID, AKEY_EVENT_ACTION_DOWN, 182 AKEY_EVENT_FLAG_FROM_SYSTEM, AKEYCODE_BUTTON_X, 121, 183 AMETA_ALT_ON, 1, ARBITRARY_DOWN_TIME, ARBITRARY_EVENT_TIME); 184 185 ASSERT_EQ(AINPUT_EVENT_TYPE_KEY, event.getType()); 186 ASSERT_EQ(2, event.getDeviceId()); 187 ASSERT_EQ(static_cast<int>(AINPUT_SOURCE_GAMEPAD), event.getSource()); 188 ASSERT_EQ(DISPLAY_ID, event.getDisplayId()); 189 ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, event.getAction()); 190 ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, event.getFlags()); 191 ASSERT_EQ(AKEYCODE_BUTTON_X, event.getKeyCode()); 192 ASSERT_EQ(121, event.getScanCode()); 193 ASSERT_EQ(AMETA_ALT_ON, event.getMetaState()); 194 ASSERT_EQ(1, event.getRepeatCount()); 195 ASSERT_EQ(ARBITRARY_DOWN_TIME, event.getDownTime()); 196 ASSERT_EQ(ARBITRARY_EVENT_TIME, event.getEventTime()); 197 198 // Set source. 199 event.setSource(AINPUT_SOURCE_JOYSTICK); 200 ASSERT_EQ(static_cast<int>(AINPUT_SOURCE_JOYSTICK), event.getSource()); 201 202 // Set display id. 203 constexpr int32_t newDisplayId = 2; 204 event.setDisplayId(newDisplayId); 205 ASSERT_EQ(newDisplayId, event.getDisplayId()); 206 } 207 208 209 // --- MotionEventTest --- 210 211 class MotionEventTest : public BaseTest { 212 protected: 213 static const nsecs_t ARBITRARY_DOWN_TIME; 214 static const nsecs_t ARBITRARY_EVENT_TIME; 215 static const float X_OFFSET; 216 static const float Y_OFFSET; 217 218 void initializeEventWithHistory(MotionEvent* event); 219 void assertEqualsEventWithHistory(const MotionEvent* event); 220 }; 221 222 const nsecs_t MotionEventTest::ARBITRARY_DOWN_TIME = 1; 223 const nsecs_t MotionEventTest::ARBITRARY_EVENT_TIME = 2; 224 const float MotionEventTest::X_OFFSET = 1.0f; 225 const float MotionEventTest::Y_OFFSET = 1.1f; 226 227 void MotionEventTest::initializeEventWithHistory(MotionEvent* event) { 228 PointerProperties pointerProperties[2]; 229 pointerProperties[0].clear(); 230 pointerProperties[0].id = 1; 231 pointerProperties[0].toolType = AMOTION_EVENT_TOOL_TYPE_FINGER; 232 pointerProperties[1].clear(); 233 pointerProperties[1].id = 2; 234 pointerProperties[1].toolType = AMOTION_EVENT_TOOL_TYPE_STYLUS; 235 236 PointerCoords pointerCoords[2]; 237 pointerCoords[0].clear(); 238 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X, 10); 239 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, 11); 240 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 12); 241 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 13); 242 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 14); 243 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 15); 244 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 16); 245 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 17); 246 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 18); 247 pointerCoords[1].clear(); 248 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_X, 20); 249 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_Y, 21); 250 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 22); 251 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 23); 252 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 24); 253 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 25); 254 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 26); 255 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 27); 256 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 28); 257 event->initialize(2, AINPUT_SOURCE_TOUCHSCREEN, DISPLAY_ID, AMOTION_EVENT_ACTION_MOVE, 0, 258 AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED, 259 AMOTION_EVENT_EDGE_FLAG_TOP, AMETA_ALT_ON, AMOTION_EVENT_BUTTON_PRIMARY, 260 MotionClassification::NONE, X_OFFSET, Y_OFFSET, 2.0f, 2.1f, 261 ARBITRARY_DOWN_TIME, ARBITRARY_EVENT_TIME, 262 2, pointerProperties, pointerCoords); 263 264 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X, 110); 265 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, 111); 266 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 112); 267 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 113); 268 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 114); 269 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 115); 270 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 116); 271 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 117); 272 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 118); 273 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_X, 120); 274 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_Y, 121); 275 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 122); 276 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 123); 277 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 124); 278 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 125); 279 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 126); 280 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 127); 281 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 128); 282 event->addSample(ARBITRARY_EVENT_TIME + 1, pointerCoords); 283 284 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X, 210); 285 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, 211); 286 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 212); 287 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 213); 288 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 214); 289 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 215); 290 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 216); 291 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 217); 292 pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 218); 293 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_X, 220); 294 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_Y, 221); 295 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 222); 296 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 223); 297 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 224); 298 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 225); 299 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 226); 300 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 227); 301 pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 228); 302 event->addSample(ARBITRARY_EVENT_TIME + 2, pointerCoords); 303 } 304 305 void MotionEventTest::assertEqualsEventWithHistory(const MotionEvent* event) { 306 // Check properties. 307 ASSERT_EQ(AINPUT_EVENT_TYPE_MOTION, event->getType()); 308 ASSERT_EQ(2, event->getDeviceId()); 309 ASSERT_EQ(static_cast<int>(AINPUT_SOURCE_TOUCHSCREEN), event->getSource()); 310 ASSERT_EQ(DISPLAY_ID, event->getDisplayId()); 311 ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, event->getAction()); 312 ASSERT_EQ(AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED, event->getFlags()); 313 ASSERT_EQ(AMOTION_EVENT_EDGE_FLAG_TOP, event->getEdgeFlags()); 314 ASSERT_EQ(AMETA_ALT_ON, event->getMetaState()); 315 ASSERT_EQ(AMOTION_EVENT_BUTTON_PRIMARY, event->getButtonState()); 316 ASSERT_EQ(MotionClassification::NONE, event->getClassification()); 317 ASSERT_EQ(X_OFFSET, event->getXOffset()); 318 ASSERT_EQ(Y_OFFSET, event->getYOffset()); 319 ASSERT_EQ(2.0f, event->getXPrecision()); 320 ASSERT_EQ(2.1f, event->getYPrecision()); 321 ASSERT_EQ(ARBITRARY_DOWN_TIME, event->getDownTime()); 322 323 ASSERT_EQ(2U, event->getPointerCount()); 324 ASSERT_EQ(1, event->getPointerId(0)); 325 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, event->getToolType(0)); 326 ASSERT_EQ(2, event->getPointerId(1)); 327 ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_STYLUS, event->getToolType(1)); 328 329 ASSERT_EQ(2U, event->getHistorySize()); 330 331 // Check data. 332 ASSERT_EQ(ARBITRARY_EVENT_TIME, event->getHistoricalEventTime(0)); 333 ASSERT_EQ(ARBITRARY_EVENT_TIME + 1, event->getHistoricalEventTime(1)); 334 ASSERT_EQ(ARBITRARY_EVENT_TIME + 2, event->getEventTime()); 335 336 ASSERT_EQ(11, event->getHistoricalRawPointerCoords(0, 0)-> 337 getAxisValue(AMOTION_EVENT_AXIS_Y)); 338 ASSERT_EQ(21, event->getHistoricalRawPointerCoords(1, 0)-> 339 getAxisValue(AMOTION_EVENT_AXIS_Y)); 340 ASSERT_EQ(111, event->getHistoricalRawPointerCoords(0, 1)-> 341 getAxisValue(AMOTION_EVENT_AXIS_Y)); 342 ASSERT_EQ(121, event->getHistoricalRawPointerCoords(1, 1)-> 343 getAxisValue(AMOTION_EVENT_AXIS_Y)); 344 ASSERT_EQ(211, event->getRawPointerCoords(0)-> 345 getAxisValue(AMOTION_EVENT_AXIS_Y)); 346 ASSERT_EQ(221, event->getRawPointerCoords(1)-> 347 getAxisValue(AMOTION_EVENT_AXIS_Y)); 348 349 ASSERT_EQ(11, event->getHistoricalRawAxisValue(AMOTION_EVENT_AXIS_Y, 0, 0)); 350 ASSERT_EQ(21, event->getHistoricalRawAxisValue(AMOTION_EVENT_AXIS_Y, 1, 0)); 351 ASSERT_EQ(111, event->getHistoricalRawAxisValue(AMOTION_EVENT_AXIS_Y, 0, 1)); 352 ASSERT_EQ(121, event->getHistoricalRawAxisValue(AMOTION_EVENT_AXIS_Y, 1, 1)); 353 ASSERT_EQ(211, event->getRawAxisValue(AMOTION_EVENT_AXIS_Y, 0)); 354 ASSERT_EQ(221, event->getRawAxisValue(AMOTION_EVENT_AXIS_Y, 1)); 355 356 ASSERT_EQ(10, event->getHistoricalRawX(0, 0)); 357 ASSERT_EQ(20, event->getHistoricalRawX(1, 0)); 358 ASSERT_EQ(110, event->getHistoricalRawX(0, 1)); 359 ASSERT_EQ(120, event->getHistoricalRawX(1, 1)); 360 ASSERT_EQ(210, event->getRawX(0)); 361 ASSERT_EQ(220, event->getRawX(1)); 362 363 ASSERT_EQ(11, event->getHistoricalRawY(0, 0)); 364 ASSERT_EQ(21, event->getHistoricalRawY(1, 0)); 365 ASSERT_EQ(111, event->getHistoricalRawY(0, 1)); 366 ASSERT_EQ(121, event->getHistoricalRawY(1, 1)); 367 ASSERT_EQ(211, event->getRawY(0)); 368 ASSERT_EQ(221, event->getRawY(1)); 369 370 ASSERT_EQ(X_OFFSET + 10, event->getHistoricalX(0, 0)); 371 ASSERT_EQ(X_OFFSET + 20, event->getHistoricalX(1, 0)); 372 ASSERT_EQ(X_OFFSET + 110, event->getHistoricalX(0, 1)); 373 ASSERT_EQ(X_OFFSET + 120, event->getHistoricalX(1, 1)); 374 ASSERT_EQ(X_OFFSET + 210, event->getX(0)); 375 ASSERT_EQ(X_OFFSET + 220, event->getX(1)); 376 377 ASSERT_EQ(Y_OFFSET + 11, event->getHistoricalY(0, 0)); 378 ASSERT_EQ(Y_OFFSET + 21, event->getHistoricalY(1, 0)); 379 ASSERT_EQ(Y_OFFSET + 111, event->getHistoricalY(0, 1)); 380 ASSERT_EQ(Y_OFFSET + 121, event->getHistoricalY(1, 1)); 381 ASSERT_EQ(Y_OFFSET + 211, event->getY(0)); 382 ASSERT_EQ(Y_OFFSET + 221, event->getY(1)); 383 384 ASSERT_EQ(12, event->getHistoricalPressure(0, 0)); 385 ASSERT_EQ(22, event->getHistoricalPressure(1, 0)); 386 ASSERT_EQ(112, event->getHistoricalPressure(0, 1)); 387 ASSERT_EQ(122, event->getHistoricalPressure(1, 1)); 388 ASSERT_EQ(212, event->getPressure(0)); 389 ASSERT_EQ(222, event->getPressure(1)); 390 391 ASSERT_EQ(13, event->getHistoricalSize(0, 0)); 392 ASSERT_EQ(23, event->getHistoricalSize(1, 0)); 393 ASSERT_EQ(113, event->getHistoricalSize(0, 1)); 394 ASSERT_EQ(123, event->getHistoricalSize(1, 1)); 395 ASSERT_EQ(213, event->getSize(0)); 396 ASSERT_EQ(223, event->getSize(1)); 397 398 ASSERT_EQ(14, event->getHistoricalTouchMajor(0, 0)); 399 ASSERT_EQ(24, event->getHistoricalTouchMajor(1, 0)); 400 ASSERT_EQ(114, event->getHistoricalTouchMajor(0, 1)); 401 ASSERT_EQ(124, event->getHistoricalTouchMajor(1, 1)); 402 ASSERT_EQ(214, event->getTouchMajor(0)); 403 ASSERT_EQ(224, event->getTouchMajor(1)); 404 405 ASSERT_EQ(15, event->getHistoricalTouchMinor(0, 0)); 406 ASSERT_EQ(25, event->getHistoricalTouchMinor(1, 0)); 407 ASSERT_EQ(115, event->getHistoricalTouchMinor(0, 1)); 408 ASSERT_EQ(125, event->getHistoricalTouchMinor(1, 1)); 409 ASSERT_EQ(215, event->getTouchMinor(0)); 410 ASSERT_EQ(225, event->getTouchMinor(1)); 411 412 ASSERT_EQ(16, event->getHistoricalToolMajor(0, 0)); 413 ASSERT_EQ(26, event->getHistoricalToolMajor(1, 0)); 414 ASSERT_EQ(116, event->getHistoricalToolMajor(0, 1)); 415 ASSERT_EQ(126, event->getHistoricalToolMajor(1, 1)); 416 ASSERT_EQ(216, event->getToolMajor(0)); 417 ASSERT_EQ(226, event->getToolMajor(1)); 418 419 ASSERT_EQ(17, event->getHistoricalToolMinor(0, 0)); 420 ASSERT_EQ(27, event->getHistoricalToolMinor(1, 0)); 421 ASSERT_EQ(117, event->getHistoricalToolMinor(0, 1)); 422 ASSERT_EQ(127, event->getHistoricalToolMinor(1, 1)); 423 ASSERT_EQ(217, event->getToolMinor(0)); 424 ASSERT_EQ(227, event->getToolMinor(1)); 425 426 ASSERT_EQ(18, event->getHistoricalOrientation(0, 0)); 427 ASSERT_EQ(28, event->getHistoricalOrientation(1, 0)); 428 ASSERT_EQ(118, event->getHistoricalOrientation(0, 1)); 429 ASSERT_EQ(128, event->getHistoricalOrientation(1, 1)); 430 ASSERT_EQ(218, event->getOrientation(0)); 431 ASSERT_EQ(228, event->getOrientation(1)); 432 } 433 434 TEST_F(MotionEventTest, Properties) { 435 MotionEvent event; 436 437 // Initialize, add samples and check properties. 438 initializeEventWithHistory(&event); 439 ASSERT_NO_FATAL_FAILURE(assertEqualsEventWithHistory(&event)); 440 441 // Set source. 442 event.setSource(AINPUT_SOURCE_JOYSTICK); 443 ASSERT_EQ(static_cast<int>(AINPUT_SOURCE_JOYSTICK), event.getSource()); 444 445 // Set displayId. 446 constexpr int32_t newDisplayId = 2; 447 event.setDisplayId(newDisplayId); 448 ASSERT_EQ(newDisplayId, event.getDisplayId()); 449 450 // Set action. 451 event.setAction(AMOTION_EVENT_ACTION_CANCEL); 452 ASSERT_EQ(AMOTION_EVENT_ACTION_CANCEL, event.getAction()); 453 454 // Set meta state. 455 event.setMetaState(AMETA_CTRL_ON); 456 ASSERT_EQ(AMETA_CTRL_ON, event.getMetaState()); 457 } 458 459 TEST_F(MotionEventTest, CopyFrom_KeepHistory) { 460 MotionEvent event; 461 initializeEventWithHistory(&event); 462 463 MotionEvent copy; 464 copy.copyFrom(&event, true /*keepHistory*/); 465 466 ASSERT_NO_FATAL_FAILURE(assertEqualsEventWithHistory(&event)); 467 } 468 469 TEST_F(MotionEventTest, CopyFrom_DoNotKeepHistory) { 470 MotionEvent event; 471 initializeEventWithHistory(&event); 472 473 MotionEvent copy; 474 copy.copyFrom(&event, false /*keepHistory*/); 475 476 ASSERT_EQ(event.getPointerCount(), copy.getPointerCount()); 477 ASSERT_EQ(0U, copy.getHistorySize()); 478 479 ASSERT_EQ(event.getPointerId(0), copy.getPointerId(0)); 480 ASSERT_EQ(event.getPointerId(1), copy.getPointerId(1)); 481 482 ASSERT_EQ(event.getEventTime(), copy.getEventTime()); 483 484 ASSERT_EQ(event.getX(0), copy.getX(0)); 485 } 486 487 TEST_F(MotionEventTest, OffsetLocation) { 488 MotionEvent event; 489 initializeEventWithHistory(&event); 490 491 event.offsetLocation(5.0f, -2.0f); 492 493 ASSERT_EQ(X_OFFSET + 5.0f, event.getXOffset()); 494 ASSERT_EQ(Y_OFFSET - 2.0f, event.getYOffset()); 495 } 496 497 TEST_F(MotionEventTest, Scale) { 498 MotionEvent event; 499 initializeEventWithHistory(&event); 500 501 event.scale(2.0f); 502 503 ASSERT_EQ(X_OFFSET * 2, event.getXOffset()); 504 ASSERT_EQ(Y_OFFSET * 2, event.getYOffset()); 505 506 ASSERT_EQ(210 * 2, event.getRawX(0)); 507 ASSERT_EQ(211 * 2, event.getRawY(0)); 508 ASSERT_EQ((X_OFFSET + 210) * 2, event.getX(0)); 509 ASSERT_EQ((Y_OFFSET + 211) * 2, event.getY(0)); 510 ASSERT_EQ(212, event.getPressure(0)); 511 ASSERT_EQ(213, event.getSize(0)); 512 ASSERT_EQ(214 * 2, event.getTouchMajor(0)); 513 ASSERT_EQ(215 * 2, event.getTouchMinor(0)); 514 ASSERT_EQ(216 * 2, event.getToolMajor(0)); 515 ASSERT_EQ(217 * 2, event.getToolMinor(0)); 516 ASSERT_EQ(218, event.getOrientation(0)); 517 } 518 519 TEST_F(MotionEventTest, Parcel) { 520 Parcel parcel; 521 522 MotionEvent inEvent; 523 initializeEventWithHistory(&inEvent); 524 MotionEvent outEvent; 525 526 // Round trip. 527 inEvent.writeToParcel(&parcel); 528 parcel.setDataPosition(0); 529 outEvent.readFromParcel(&parcel); 530 531 ASSERT_NO_FATAL_FAILURE(assertEqualsEventWithHistory(&outEvent)); 532 } 533 534 static void setRotationMatrix(float matrix[9], float angle) { 535 float sin = sinf(angle); 536 float cos = cosf(angle); 537 matrix[0] = cos; 538 matrix[1] = -sin; 539 matrix[2] = 0; 540 matrix[3] = sin; 541 matrix[4] = cos; 542 matrix[5] = 0; 543 matrix[6] = 0; 544 matrix[7] = 0; 545 matrix[8] = 1.0f; 546 } 547 548 TEST_F(MotionEventTest, Transform) { 549 // Generate some points on a circle. 550 // Each point 'i' is a point on a circle of radius ROTATION centered at (3,2) at an angle 551 // of ARC * i degrees clockwise relative to the Y axis. 552 // The geometrical representation is irrelevant to the test, it's just easy to generate 553 // and check rotation. We set the orientation to the same angle. 554 // Coordinate system: down is increasing Y, right is increasing X. 555 const float PI_180 = float(M_PI / 180); 556 const float RADIUS = 10; 557 const float ARC = 36; 558 const float ROTATION = ARC * 2; 559 560 const size_t pointerCount = 11; 561 PointerProperties pointerProperties[pointerCount]; 562 PointerCoords pointerCoords[pointerCount]; 563 for (size_t i = 0; i < pointerCount; i++) { 564 float angle = float(i * ARC * PI_180); 565 pointerProperties[i].clear(); 566 pointerProperties[i].id = i; 567 pointerCoords[i].clear(); 568 pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_X, sinf(angle) * RADIUS + 3); 569 pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_Y, -cosf(angle) * RADIUS + 2); 570 pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, angle); 571 } 572 MotionEvent event; 573 event.initialize(0 /*deviceId*/, AINPUT_SOURCE_UNKNOWN, DISPLAY_ID, AMOTION_EVENT_ACTION_MOVE, 574 0 /*actionButton*/, 0 /*flags*/, AMOTION_EVENT_EDGE_FLAG_NONE, 575 AMETA_NONE, 0 /*buttonState*/, MotionClassification::NONE, 576 0 /*xOffset*/, 0 /*yOffset*/, 0 /*xPrecision*/, 0 /*yPrecision*/, 577 0 /*downTime*/, 0 /*eventTime*/, pointerCount, pointerProperties, pointerCoords); 578 float originalRawX = 0 + 3; 579 float originalRawY = -RADIUS + 2; 580 581 // Check original raw X and Y assumption. 582 ASSERT_NEAR(originalRawX, event.getRawX(0), 0.001); 583 ASSERT_NEAR(originalRawY, event.getRawY(0), 0.001); 584 585 // Now translate the motion event so the circle's origin is at (0,0). 586 event.offsetLocation(-3, -2); 587 588 // Offsetting the location should preserve the raw X and Y of the first point. 589 ASSERT_NEAR(originalRawX, event.getRawX(0), 0.001); 590 ASSERT_NEAR(originalRawY, event.getRawY(0), 0.001); 591 592 // Apply a rotation about the origin by ROTATION degrees clockwise. 593 float matrix[9]; 594 setRotationMatrix(matrix, ROTATION * PI_180); 595 event.transform(matrix); 596 597 // Check the points. 598 for (size_t i = 0; i < pointerCount; i++) { 599 float angle = float((i * ARC + ROTATION) * PI_180); 600 ASSERT_NEAR(sinf(angle) * RADIUS, event.getX(i), 0.001); 601 ASSERT_NEAR(-cosf(angle) * RADIUS, event.getY(i), 0.001); 602 ASSERT_NEAR(tanf(angle), tanf(event.getOrientation(i)), 0.1); 603 } 604 605 // Applying the transformation should preserve the raw X and Y of the first point. 606 ASSERT_NEAR(originalRawX, event.getRawX(0), 0.001); 607 ASSERT_NEAR(originalRawY, event.getRawY(0), 0.001); 608 } 609 610 TEST_F(MotionEventTest, Initialize_SetsClassification) { 611 std::array<MotionClassification, 3> classifications = { 612 MotionClassification::NONE, 613 MotionClassification::AMBIGUOUS_GESTURE, 614 MotionClassification::DEEP_PRESS, 615 }; 616 617 MotionEvent event; 618 constexpr size_t pointerCount = 1; 619 PointerProperties pointerProperties[pointerCount]; 620 PointerCoords pointerCoords[pointerCount]; 621 for (size_t i = 0; i < pointerCount; i++) { 622 pointerProperties[i].clear(); 623 pointerProperties[i].id = i; 624 pointerCoords[i].clear(); 625 } 626 627 for (MotionClassification classification : classifications) { 628 event.initialize(0 /*deviceId*/, AINPUT_SOURCE_TOUCHSCREEN, DISPLAY_ID, 629 AMOTION_EVENT_ACTION_DOWN, 0, 0, AMOTION_EVENT_EDGE_FLAG_NONE, AMETA_NONE, 0, 630 classification, 0, 0, 0, 0, 0 /*downTime*/, 0 /*eventTime*/, 631 pointerCount, pointerProperties, pointerCoords); 632 ASSERT_EQ(classification, event.getClassification()); 633 } 634 } 635 636 } // namespace android 637
