1 /* 2 * Copyright (C) 2017 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 #define LOG_TAG "VelocityTracker_test" 18 19 #include <array> 20 #include <chrono> 21 #include <math.h> 22 23 #include <android-base/stringprintf.h> 24 #include <gtest/gtest.h> 25 #include <input/VelocityTracker.h> 26 27 using namespace std::chrono_literals; 28 using android::base::StringPrintf; 29 30 namespace android { 31 32 constexpr int32_t DISPLAY_ID = ADISPLAY_ID_DEFAULT; // default display id 33 34 constexpr int32_t DEFAULT_POINTER_ID = 0; // pointer ID used for manually defined tests 35 36 // velocity must be in the range (1-tol)*EV <= velocity <= (1+tol)*EV 37 // here EV = expected value, tol = VELOCITY_TOLERANCE 38 constexpr float VELOCITY_TOLERANCE = 0.2; 39 40 // estimate coefficients must be within 0.001% of the target value 41 constexpr float COEFFICIENT_TOLERANCE = 0.00001; 42 43 // --- VelocityTrackerTest --- 44 class VelocityTrackerTest : public testing::Test { }; 45 46 /* 47 * Similar to EXPECT_NEAR, but ensures that the difference between the two float values 48 * is at most a certain fraction of the target value. 49 * If fraction is zero, require exact match. 50 */ 51 static void EXPECT_NEAR_BY_FRACTION(float actual, float target, float fraction) { 52 float tolerance = fabsf(target * fraction); 53 54 if (target == 0 && fraction != 0) { 55 // If target is zero, this would force actual == target, which is too harsh. 56 // Relax this requirement a little. The value is determined empirically from the 57 // coefficients computed by the quadratic least squares algorithms. 58 tolerance = 1E-6; 59 } 60 EXPECT_NEAR(actual, target, tolerance); 61 } 62 63 static void checkVelocity(float Vactual, float Vtarget) { 64 EXPECT_NEAR_BY_FRACTION(Vactual, Vtarget, VELOCITY_TOLERANCE); 65 } 66 67 static void checkCoefficient(float actual, float target) { 68 EXPECT_NEAR_BY_FRACTION(actual, target, COEFFICIENT_TOLERANCE); 69 } 70 71 struct Position { 72 float x; 73 float y; 74 75 /** 76 * If both values are NAN, then this is considered to be an empty entry (no pointer data). 77 * If only one of the values is NAN, this is still a valid entry, 78 * because we may only care about a single axis. 79 */ 80 bool isValid() const { 81 return !(isnan(x) && isnan(y)); 82 } 83 }; 84 85 struct MotionEventEntry { 86 std::chrono::nanoseconds eventTime; 87 std::vector<Position> positions; 88 }; 89 90 static BitSet32 getValidPointers(const std::vector<Position>& positions) { 91 BitSet32 pointers; 92 for (size_t i = 0; i < positions.size(); i++) { 93 if (positions[i].isValid()) { 94 pointers.markBit(i); 95 } 96 } 97 return pointers; 98 } 99 100 static uint32_t getChangingPointerId(BitSet32 pointers, BitSet32 otherPointers) { 101 BitSet32 difference(pointers.value ^ otherPointers.value); 102 uint32_t pointerId = difference.clearFirstMarkedBit(); 103 EXPECT_EQ(0U, difference.value) << "Only 1 pointer can enter or leave at a time"; 104 return pointerId; 105 } 106 107 static int32_t resolveAction(const std::vector<Position>& lastPositions, 108 const std::vector<Position>& currentPositions, 109 const std::vector<Position>& nextPositions) { 110 BitSet32 pointers = getValidPointers(currentPositions); 111 const uint32_t pointerCount = pointers.count(); 112 113 BitSet32 lastPointers = getValidPointers(lastPositions); 114 const uint32_t lastPointerCount = lastPointers.count(); 115 if (lastPointerCount < pointerCount) { 116 // A new pointer is down 117 uint32_t pointerId = getChangingPointerId(pointers, lastPointers); 118 return AMOTION_EVENT_ACTION_POINTER_DOWN | 119 (pointerId << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT); 120 } 121 122 BitSet32 nextPointers = getValidPointers(nextPositions); 123 const uint32_t nextPointerCount = nextPointers.count(); 124 if (pointerCount > nextPointerCount) { 125 // An existing pointer is leaving 126 uint32_t pointerId = getChangingPointerId(pointers, nextPointers); 127 return AMOTION_EVENT_ACTION_POINTER_UP | 128 (pointerId << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT); 129 } 130 131 return AMOTION_EVENT_ACTION_MOVE; 132 } 133 134 static std::vector<MotionEvent> createMotionEventStream( 135 const std::vector<MotionEventEntry>& motions) { 136 if (motions.empty()) { 137 ADD_FAILURE() << "Need at least 1 sample to create a MotionEvent. Received empty vector."; 138 } 139 140 std::vector<MotionEvent> events; 141 for (size_t i = 0; i < motions.size(); i++) { 142 const MotionEventEntry& entry = motions[i]; 143 BitSet32 pointers = getValidPointers(entry.positions); 144 const uint32_t pointerCount = pointers.count(); 145 146 int32_t action; 147 if (i == 0) { 148 action = AMOTION_EVENT_ACTION_DOWN; 149 EXPECT_EQ(1U, pointerCount) << "First event should only have 1 pointer"; 150 } else if (i == motions.size() - 1) { 151 EXPECT_EQ(1U, pointerCount) << "Last event should only have 1 pointer"; 152 action = AMOTION_EVENT_ACTION_UP; 153 } else { 154 const MotionEventEntry& previousEntry = motions[i-1]; 155 const MotionEventEntry& nextEntry = motions[i+1]; 156 action = resolveAction(previousEntry.positions, entry.positions, nextEntry.positions); 157 } 158 159 PointerCoords coords[pointerCount]; 160 PointerProperties properties[pointerCount]; 161 uint32_t pointerIndex = 0; 162 while(!pointers.isEmpty()) { 163 uint32_t pointerId = pointers.clearFirstMarkedBit(); 164 165 coords[pointerIndex].clear(); 166 // We are treating column positions as pointerId 167 EXPECT_TRUE(entry.positions[pointerId].isValid()) << 168 "The entry at pointerId must be valid"; 169 coords[pointerIndex].setAxisValue(AMOTION_EVENT_AXIS_X, entry.positions[pointerId].x); 170 coords[pointerIndex].setAxisValue(AMOTION_EVENT_AXIS_Y, entry.positions[pointerId].y); 171 172 properties[pointerIndex].id = pointerId; 173 properties[pointerIndex].toolType = AMOTION_EVENT_TOOL_TYPE_FINGER; 174 pointerIndex++; 175 } 176 EXPECT_EQ(pointerIndex, pointerCount); 177 178 MotionEvent event; 179 event.initialize(0 /*deviceId*/, AINPUT_SOURCE_TOUCHSCREEN, DISPLAY_ID, 180 action, 0 /*actionButton*/, 0 /*flags*/, 181 AMOTION_EVENT_EDGE_FLAG_NONE, AMETA_NONE, 0 /*buttonState*/, 182 MotionClassification::NONE, 183 0 /*xOffset*/, 0 /*yOffset*/, 0 /*xPrecision*/, 0 /*yPrecision*/, 184 0 /*downTime*/, entry.eventTime.count(), pointerCount, properties, coords); 185 186 events.emplace_back(event); 187 } 188 189 return events; 190 } 191 192 static void computeAndCheckVelocity(const char* strategy, 193 const std::vector<MotionEventEntry>& motions, int32_t axis, float targetVelocity) { 194 VelocityTracker vt(strategy); 195 float Vx, Vy; 196 197 std::vector<MotionEvent> events = createMotionEventStream(motions); 198 for (MotionEvent event : events) { 199 vt.addMovement(&event); 200 } 201 202 vt.getVelocity(DEFAULT_POINTER_ID, &Vx, &Vy); 203 204 switch (axis) { 205 case AMOTION_EVENT_AXIS_X: 206 checkVelocity(Vx, targetVelocity); 207 break; 208 case AMOTION_EVENT_AXIS_Y: 209 checkVelocity(Vy, targetVelocity); 210 break; 211 default: 212 FAIL() << "Axis must be either AMOTION_EVENT_AXIS_X or AMOTION_EVENT_AXIS_Y"; 213 } 214 } 215 216 static void computeAndCheckQuadraticEstimate(const std::vector<MotionEventEntry>& motions, 217 const std::array<float, 3>& coefficients) { 218 VelocityTracker vt("lsq2"); 219 std::vector<MotionEvent> events = createMotionEventStream(motions); 220 for (MotionEvent event : events) { 221 vt.addMovement(&event); 222 } 223 VelocityTracker::Estimator estimator; 224 EXPECT_TRUE(vt.getEstimator(0, &estimator)); 225 for (size_t i = 0; i< coefficients.size(); i++) { 226 checkCoefficient(estimator.xCoeff[i], coefficients[i]); 227 checkCoefficient(estimator.yCoeff[i], coefficients[i]); 228 } 229 } 230 231 /* 232 * ================== VelocityTracker tests generated manually ===================================== 233 */ 234 TEST_F(VelocityTrackerTest, ThreePointsPositiveVelocityTest) { 235 // Same coordinate is reported 2 times in a row 236 // It is difficult to determine the correct answer here, but at least the direction 237 // of the reported velocity should be positive. 238 std::vector<MotionEventEntry> motions = { 239 {0ms, {{ 273, NAN}}}, 240 {12585us, {{293, NAN}}}, 241 {14730us, {{293, NAN}}}, 242 {14730us, {{293, NAN}}}, // ACTION_UP 243 }; 244 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_X, 1600); 245 } 246 247 TEST_F(VelocityTrackerTest, ThreePointsZeroVelocityTest) { 248 // Same coordinate is reported 3 times in a row 249 std::vector<MotionEventEntry> motions = { 250 { 0ms, {{293, NAN}} }, 251 { 6132us, {{293, NAN}} }, 252 { 11283us, {{293, NAN}} }, 253 { 11283us, {{293, NAN}} }, // ACTION_UP 254 }; 255 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_X, 0); 256 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_X, 0); 257 } 258 259 TEST_F(VelocityTrackerTest, ThreePointsLinearVelocityTest) { 260 // Fixed velocity at 5 points per 10 milliseconds 261 std::vector<MotionEventEntry> motions = { 262 { 0ms, {{0, NAN}} }, 263 { 10ms, {{5, NAN}} }, 264 { 20ms, {{10, NAN}} }, 265 { 20ms, {{10, NAN}} }, // ACTION_UP 266 }; 267 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_X, 500); 268 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_X, 500); 269 } 270 271 272 /** 273 * ================== VelocityTracker tests generated by recording real events ===================== 274 * 275 * To add a test, record the input coordinates and event times to all calls 276 * to void VelocityTracker::addMovement(const MotionEvent* event). 277 * Also record all calls to VelocityTracker::clear(). 278 * Finally, record the output of VelocityTracker::getVelocity(...) 279 * This will give you the necessary data to create a new test. 280 * 281 * Another good way to generate this data is to use 'dumpsys input' just after the event has 282 * occurred. 283 */ 284 285 // --------------- Recorded by hand on swordfish --------------------------------------------------- 286 TEST_F(VelocityTrackerTest, SwordfishFlingDown) { 287 // Recording of a fling on Swordfish that could cause a fling in the wrong direction 288 std::vector<MotionEventEntry> motions = { 289 { 0ms, {{271, 96}} }, 290 { 16071042ns, {{269.786346, 106.922775}} }, 291 { 35648403ns, {{267.983063, 156.660034}} }, 292 { 52313925ns, {{262.638397, 220.339081}} }, 293 { 68976522ns, {{266.138824, 331.581116}} }, 294 { 85639375ns, {{274.79245, 428.113159}} }, 295 { 96948871ns, {{274.79245, 428.113159}} }, 296 { 96948871ns, {{274.79245, 428.113159}} }, // ACTION_UP 297 }; 298 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_X, 623.577637); 299 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, 5970.7309); 300 } 301 302 // --------------- Recorded by hand on sailfish, generated by a script ----------------------------- 303 // For some of these tests, the X-direction velocity checking has been removed, because the lsq2 304 // and the impulse VelocityTrackerStrategies did not agree within 20%. 305 // Since the flings were recorded in the Y-direction, the intentional user action should only 306 // be relevant for the Y axis. 307 // There have been also cases where lsq2 and impulse disagreed more than 20% in the Y-direction. 308 // Those recordings have been discarded because we didn't feel one strategy's interpretation was 309 // more correct than another's but didn't want to increase the tolerance for the entire test suite. 310 // 311 // There are 18 tests total below: 9 in the positive Y direction and 9 in the opposite. 312 // The recordings were loosely binned into 3 categories - slow, faster, and fast, which roughly 313 // characterizes the velocity of the finger motion. 314 // These can be treated approximately as: 315 // slow - less than 1 page gets scrolled 316 // faster - more than 1 page gets scrolled, but less than 3 317 // fast - entire list is scrolled (fling is done as hard as possible) 318 319 TEST_F(VelocityTrackerTest, SailfishFlingUpSlow1) { 320 // Sailfish - fling up - slow - 1 321 std::vector<MotionEventEntry> motions = { 322 { 235089067457000ns, {{528.00, 983.00}} }, 323 { 235089084684000ns, {{527.00, 981.00}} }, 324 { 235089093349000ns, {{527.00, 977.00}} }, 325 { 235089095677625ns, {{527.00, 975.93}} }, 326 { 235089101859000ns, {{527.00, 970.00}} }, 327 { 235089110378000ns, {{528.00, 960.00}} }, 328 { 235089112497111ns, {{528.25, 957.51}} }, 329 { 235089118760000ns, {{531.00, 946.00}} }, 330 { 235089126686000ns, {{535.00, 931.00}} }, 331 { 235089129316820ns, {{536.33, 926.02}} }, 332 { 235089135199000ns, {{540.00, 914.00}} }, 333 { 235089144297000ns, {{546.00, 896.00}} }, 334 { 235089146136443ns, {{547.21, 892.36}} }, 335 { 235089152923000ns, {{553.00, 877.00}} }, 336 { 235089160784000ns, {{559.00, 851.00}} }, 337 { 235089162955851ns, {{560.66, 843.82}} }, 338 { 235089162955851ns, {{560.66, 843.82}} }, // ACTION_UP 339 }; 340 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_X, 872.794617); 341 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_X, 951.698181); 342 computeAndCheckVelocity("impulse",motions, AMOTION_EVENT_AXIS_Y, -3604.819336); 343 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, -3044.966064); 344 } 345 346 347 TEST_F(VelocityTrackerTest, SailfishFlingUpSlow2) { 348 // Sailfish - fling up - slow - 2 349 std::vector<MotionEventEntry> motions = { 350 { 235110560704000ns, {{522.00, 1107.00}} }, 351 { 235110575764000ns, {{522.00, 1107.00}} }, 352 { 235110584385000ns, {{522.00, 1107.00}} }, 353 { 235110588421179ns, {{521.52, 1106.52}} }, 354 { 235110592830000ns, {{521.00, 1106.00}} }, 355 { 235110601385000ns, {{520.00, 1104.00}} }, 356 { 235110605088160ns, {{519.14, 1102.27}} }, 357 { 235110609952000ns, {{518.00, 1100.00}} }, 358 { 235110618353000ns, {{517.00, 1093.00}} }, 359 { 235110621755146ns, {{516.60, 1090.17}} }, 360 { 235110627010000ns, {{517.00, 1081.00}} }, 361 { 235110634785000ns, {{518.00, 1063.00}} }, 362 { 235110638422450ns, {{518.87, 1052.58}} }, 363 { 235110643161000ns, {{520.00, 1039.00}} }, 364 { 235110651767000ns, {{524.00, 1011.00}} }, 365 { 235110655089581ns, {{525.54, 1000.19}} }, 366 { 235110660368000ns, {{530.00, 980.00}} }, 367 { 235110660368000ns, {{530.00, 980.00}} }, // ACTION_UP 368 }; 369 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, -4096.583008); 370 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, -3455.094238); 371 } 372 373 374 TEST_F(VelocityTrackerTest, SailfishFlingUpSlow3) { 375 // Sailfish - fling up - slow - 3 376 std::vector<MotionEventEntry> motions = { 377 { 792536237000ns, {{580.00, 1317.00}} }, 378 { 792541538987ns, {{580.63, 1311.94}} }, 379 { 792544613000ns, {{581.00, 1309.00}} }, 380 { 792552301000ns, {{583.00, 1295.00}} }, 381 { 792558362309ns, {{585.13, 1282.92}} }, 382 { 792560828000ns, {{586.00, 1278.00}} }, 383 { 792569446000ns, {{589.00, 1256.00}} }, 384 { 792575185095ns, {{591.54, 1241.41}} }, 385 { 792578491000ns, {{593.00, 1233.00}} }, 386 { 792587044000ns, {{597.00, 1211.00}} }, 387 { 792592008172ns, {{600.28, 1195.92}} }, 388 { 792594616000ns, {{602.00, 1188.00}} }, 389 { 792603129000ns, {{607.00, 1167.00}} }, 390 { 792608831290ns, {{609.48, 1155.83}} }, 391 { 792612321000ns, {{611.00, 1149.00}} }, 392 { 792620768000ns, {{615.00, 1131.00}} }, 393 { 792625653873ns, {{617.32, 1121.73}} }, 394 { 792629200000ns, {{619.00, 1115.00}} }, 395 { 792629200000ns, {{619.00, 1115.00}} }, // ACTION_UP 396 }; 397 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_X, 574.33429); 398 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_X, 617.40564); 399 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, -2361.982666); 400 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, -2500.055664); 401 } 402 403 404 TEST_F(VelocityTrackerTest, SailfishFlingUpFaster1) { 405 // Sailfish - fling up - faster - 1 406 std::vector<MotionEventEntry> motions = { 407 { 235160420675000ns, {{610.00, 1042.00}} }, 408 { 235160428220000ns, {{609.00, 1026.00}} }, 409 { 235160436544000ns, {{609.00, 1024.00}} }, 410 { 235160441852394ns, {{609.64, 1020.82}} }, 411 { 235160444878000ns, {{610.00, 1019.00}} }, 412 { 235160452673000ns, {{613.00, 1006.00}} }, 413 { 235160458519743ns, {{617.18, 992.06}} }, 414 { 235160461061000ns, {{619.00, 986.00}} }, 415 { 235160469798000ns, {{627.00, 960.00}} }, 416 { 235160475186713ns, {{632.22, 943.02}} }, 417 { 235160478051000ns, {{635.00, 934.00}} }, 418 { 235160486489000ns, {{644.00, 906.00}} }, 419 { 235160491853697ns, {{649.56, 890.56}} }, 420 { 235160495177000ns, {{653.00, 881.00}} }, 421 { 235160504148000ns, {{662.00, 858.00}} }, 422 { 235160509231495ns, {{666.81, 845.37}} }, 423 { 235160512603000ns, {{670.00, 837.00}} }, 424 { 235160520366000ns, {{679.00, 814.00}} }, 425 { 235160520366000ns, {{679.00, 814.00}} }, // ACTION_UP 426 }; 427 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_X, 1274.141724); 428 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_X, 1438.53186); 429 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, -3001.4348); 430 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, -3695.859619); 431 } 432 433 434 TEST_F(VelocityTrackerTest, SailfishFlingUpFaster2) { 435 // Sailfish - fling up - faster - 2 436 std::vector<MotionEventEntry> motions = { 437 { 847153808000ns, {{576.00, 1264.00}} }, 438 { 847171174000ns, {{576.00, 1262.00}} }, 439 { 847179640000ns, {{576.00, 1257.00}} }, 440 { 847185187540ns, {{577.41, 1249.22}} }, 441 { 847187487000ns, {{578.00, 1246.00}} }, 442 { 847195710000ns, {{581.00, 1227.00}} }, 443 { 847202027059ns, {{583.93, 1209.40}} }, 444 { 847204324000ns, {{585.00, 1203.00}} }, 445 { 847212672000ns, {{590.00, 1176.00}} }, 446 { 847218861395ns, {{594.36, 1157.11}} }, 447 { 847221190000ns, {{596.00, 1150.00}} }, 448 { 847230484000ns, {{602.00, 1124.00}} }, 449 { 847235701400ns, {{607.56, 1103.83}} }, 450 { 847237986000ns, {{610.00, 1095.00}} }, 451 { 847237986000ns, {{610.00, 1095.00}} }, // ACTION_UP 452 }; 453 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, -4280.07959); 454 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, -4241.004395); 455 } 456 457 458 TEST_F(VelocityTrackerTest, SailfishFlingUpFaster3) { 459 // Sailfish - fling up - faster - 3 460 std::vector<MotionEventEntry> motions = { 461 { 235200532789000ns, {{507.00, 1084.00}} }, 462 { 235200549221000ns, {{507.00, 1083.00}} }, 463 { 235200557841000ns, {{507.00, 1081.00}} }, 464 { 235200558051189ns, {{507.00, 1080.95}} }, 465 { 235200566314000ns, {{507.00, 1078.00}} }, 466 { 235200574876586ns, {{508.97, 1070.12}} }, 467 { 235200575006000ns, {{509.00, 1070.00}} }, 468 { 235200582900000ns, {{514.00, 1054.00}} }, 469 { 235200591276000ns, {{525.00, 1023.00}} }, 470 { 235200591701829ns, {{525.56, 1021.42}} }, 471 { 235200600064000ns, {{542.00, 976.00}} }, 472 { 235200608519000ns, {{563.00, 911.00}} }, 473 { 235200608527086ns, {{563.02, 910.94}} }, 474 { 235200616933000ns, {{590.00, 844.00}} }, 475 { 235200616933000ns, {{590.00, 844.00}} }, // ACTION_UP 476 }; 477 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, -8715.686523); 478 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, -7639.026367); 479 } 480 481 482 TEST_F(VelocityTrackerTest, SailfishFlingUpFast1) { 483 // Sailfish - fling up - fast - 1 484 std::vector<MotionEventEntry> motions = { 485 { 920922149000ns, {{561.00, 1412.00}} }, 486 { 920930185000ns, {{559.00, 1377.00}} }, 487 { 920930262463ns, {{558.98, 1376.66}} }, 488 { 920938547000ns, {{559.00, 1371.00}} }, 489 { 920947096857ns, {{562.91, 1342.68}} }, 490 { 920947302000ns, {{563.00, 1342.00}} }, 491 { 920955502000ns, {{577.00, 1272.00}} }, 492 { 920963931021ns, {{596.87, 1190.54}} }, 493 { 920963987000ns, {{597.00, 1190.00}} }, 494 { 920972530000ns, {{631.00, 1093.00}} }, 495 { 920980765511ns, {{671.31, 994.68}} }, 496 { 920980906000ns, {{672.00, 993.00}} }, 497 { 920989261000ns, {{715.00, 903.00}} }, 498 { 920989261000ns, {{715.00, 903.00}} }, // ACTION_UP 499 }; 500 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_X, 5670.329102); 501 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_X, 5991.866699); 502 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, -13021.101562); 503 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, -15093.995117); 504 } 505 506 507 TEST_F(VelocityTrackerTest, SailfishFlingUpFast2) { 508 // Sailfish - fling up - fast - 2 509 std::vector<MotionEventEntry> motions = { 510 { 235247153233000ns, {{518.00, 1168.00}} }, 511 { 235247170452000ns, {{517.00, 1167.00}} }, 512 { 235247178908000ns, {{515.00, 1159.00}} }, 513 { 235247179556213ns, {{514.85, 1158.39}} }, 514 { 235247186821000ns, {{515.00, 1125.00}} }, 515 { 235247195265000ns, {{521.00, 1051.00}} }, 516 { 235247196389476ns, {{521.80, 1041.15}} }, 517 { 235247203649000ns, {{538.00, 932.00}} }, 518 { 235247212253000ns, {{571.00, 794.00}} }, 519 { 235247213222491ns, {{574.72, 778.45}} }, 520 { 235247220736000ns, {{620.00, 641.00}} }, 521 { 235247220736000ns, {{620.00, 641.00}} }, // ACTION_UP 522 }; 523 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, -20286.958984); 524 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, -20494.587891); 525 } 526 527 528 TEST_F(VelocityTrackerTest, SailfishFlingUpFast3) { 529 // Sailfish - fling up - fast - 3 530 std::vector<MotionEventEntry> motions = { 531 { 235302568736000ns, {{529.00, 1167.00}} }, 532 { 235302576644000ns, {{523.00, 1140.00}} }, 533 { 235302579395063ns, {{520.91, 1130.61}} }, 534 { 235302585140000ns, {{522.00, 1130.00}} }, 535 { 235302593615000ns, {{527.00, 1065.00}} }, 536 { 235302596207444ns, {{528.53, 1045.12}} }, 537 { 235302602102000ns, {{559.00, 872.00}} }, 538 { 235302610545000ns, {{652.00, 605.00}} }, 539 { 235302613019881ns, {{679.26, 526.73}} }, 540 { 235302613019881ns, {{679.26, 526.73}} }, // ACTION_UP 541 }; 542 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, -39295.941406); 543 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, -36461.421875); 544 } 545 546 547 TEST_F(VelocityTrackerTest, SailfishFlingDownSlow1) { 548 // Sailfish - fling down - slow - 1 549 std::vector<MotionEventEntry> motions = { 550 { 235655749552755ns, {{582.00, 432.49}} }, 551 { 235655750638000ns, {{582.00, 433.00}} }, 552 { 235655758865000ns, {{582.00, 440.00}} }, 553 { 235655766221523ns, {{581.16, 448.43}} }, 554 { 235655767594000ns, {{581.00, 450.00}} }, 555 { 235655776044000ns, {{580.00, 462.00}} }, 556 { 235655782890696ns, {{579.18, 474.35}} }, 557 { 235655784360000ns, {{579.00, 477.00}} }, 558 { 235655792795000ns, {{578.00, 496.00}} }, 559 { 235655799559531ns, {{576.27, 515.04}} }, 560 { 235655800612000ns, {{576.00, 518.00}} }, 561 { 235655809535000ns, {{574.00, 542.00}} }, 562 { 235655816988015ns, {{572.17, 564.86}} }, 563 { 235655817685000ns, {{572.00, 567.00}} }, 564 { 235655825981000ns, {{569.00, 595.00}} }, 565 { 235655833808653ns, {{566.26, 620.60}} }, 566 { 235655834541000ns, {{566.00, 623.00}} }, 567 { 235655842893000ns, {{563.00, 649.00}} }, 568 { 235655842893000ns, {{563.00, 649.00}} }, // ACTION_UP 569 }; 570 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_X, -419.749695); 571 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_X, -398.303894); 572 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, 3309.016357); 573 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, 3969.099854); 574 } 575 576 577 TEST_F(VelocityTrackerTest, SailfishFlingDownSlow2) { 578 // Sailfish - fling down - slow - 2 579 std::vector<MotionEventEntry> motions = { 580 { 235671152083370ns, {{485.24, 558.28}} }, 581 { 235671154126000ns, {{485.00, 559.00}} }, 582 { 235671162497000ns, {{484.00, 566.00}} }, 583 { 235671168750511ns, {{483.27, 573.29}} }, 584 { 235671171071000ns, {{483.00, 576.00}} }, 585 { 235671179390000ns, {{482.00, 588.00}} }, 586 { 235671185417210ns, {{481.31, 598.98}} }, 587 { 235671188173000ns, {{481.00, 604.00}} }, 588 { 235671196371000ns, {{480.00, 624.00}} }, 589 { 235671202084196ns, {{479.27, 639.98}} }, 590 { 235671204235000ns, {{479.00, 646.00}} }, 591 { 235671212554000ns, {{478.00, 673.00}} }, 592 { 235671219471011ns, {{476.39, 697.12}} }, 593 { 235671221159000ns, {{476.00, 703.00}} }, 594 { 235671229592000ns, {{474.00, 734.00}} }, 595 { 235671236281462ns, {{472.43, 758.38}} }, 596 { 235671238098000ns, {{472.00, 765.00}} }, 597 { 235671246532000ns, {{470.00, 799.00}} }, 598 { 235671246532000ns, {{470.00, 799.00}} }, // ACTION_UP 599 }; 600 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_X, -262.80426); 601 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_X, -243.665344); 602 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, 4215.682129); 603 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, 4587.986816); 604 } 605 606 607 TEST_F(VelocityTrackerTest, SailfishFlingDownSlow3) { 608 // Sailfish - fling down - slow - 3 609 std::vector<MotionEventEntry> motions = { 610 { 170983201000ns, {{557.00, 533.00}} }, 611 { 171000668000ns, {{556.00, 534.00}} }, 612 { 171007359750ns, {{554.73, 535.27}} }, 613 { 171011197000ns, {{554.00, 536.00}} }, 614 { 171017660000ns, {{552.00, 540.00}} }, 615 { 171024201831ns, {{549.97, 544.73}} }, 616 { 171027333000ns, {{549.00, 547.00}} }, 617 { 171034603000ns, {{545.00, 557.00}} }, 618 { 171041043371ns, {{541.98, 567.55}} }, 619 { 171043147000ns, {{541.00, 571.00}} }, 620 { 171051052000ns, {{536.00, 586.00}} }, 621 { 171051052000ns, {{536.00, 586.00}} }, // ACTION_UP 622 }; 623 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_X, -723.413513); 624 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_X, -651.038452); 625 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, 2091.502441); 626 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, 1934.517456); 627 } 628 629 630 TEST_F(VelocityTrackerTest, SailfishFlingDownFaster1) { 631 // Sailfish - fling down - faster - 1 632 std::vector<MotionEventEntry> motions = { 633 { 235695280333000ns, {{558.00, 451.00}} }, 634 { 235695283971237ns, {{558.43, 454.45}} }, 635 { 235695289038000ns, {{559.00, 462.00}} }, 636 { 235695297388000ns, {{561.00, 478.00}} }, 637 { 235695300638465ns, {{561.83, 486.25}} }, 638 { 235695305265000ns, {{563.00, 498.00}} }, 639 { 235695313591000ns, {{564.00, 521.00}} }, 640 { 235695317305492ns, {{564.43, 532.68}} }, 641 { 235695322181000ns, {{565.00, 548.00}} }, 642 { 235695330709000ns, {{565.00, 577.00}} }, 643 { 235695333972227ns, {{565.00, 588.10}} }, 644 { 235695339250000ns, {{565.00, 609.00}} }, 645 { 235695347839000ns, {{565.00, 642.00}} }, 646 { 235695351313257ns, {{565.00, 656.18}} }, 647 { 235695356412000ns, {{565.00, 677.00}} }, 648 { 235695364899000ns, {{563.00, 710.00}} }, 649 { 235695368118682ns, {{562.24, 722.52}} }, 650 { 235695373403000ns, {{564.00, 744.00}} }, 651 { 235695373403000ns, {{564.00, 744.00}} }, // ACTION_UP 652 }; 653 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, 4254.639648); 654 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, 4698.415039); 655 } 656 657 658 TEST_F(VelocityTrackerTest, SailfishFlingDownFaster2) { 659 // Sailfish - fling down - faster - 2 660 std::vector<MotionEventEntry> motions = { 661 { 235709624766000ns, {{535.00, 579.00}} }, 662 { 235709642256000ns, {{534.00, 580.00}} }, 663 { 235709643350278ns, {{533.94, 580.06}} }, 664 { 235709650760000ns, {{532.00, 584.00}} }, 665 { 235709658615000ns, {{530.00, 593.00}} }, 666 { 235709660170495ns, {{529.60, 594.78}} }, 667 { 235709667095000ns, {{527.00, 606.00}} }, 668 { 235709675616000ns, {{524.00, 628.00}} }, 669 { 235709676983261ns, {{523.52, 631.53}} }, 670 { 235709684289000ns, {{521.00, 652.00}} }, 671 { 235709692763000ns, {{518.00, 682.00}} }, 672 { 235709693804993ns, {{517.63, 685.69}} }, 673 { 235709701438000ns, {{515.00, 709.00}} }, 674 { 235709709830000ns, {{512.00, 739.00}} }, 675 { 235709710626776ns, {{511.72, 741.85}} }, 676 { 235709710626776ns, {{511.72, 741.85}} }, // ACTION_UP 677 }; 678 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_X, -430.440247); 679 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_X, -447.600311); 680 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, 3953.859375); 681 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, 4316.155273); 682 } 683 684 685 TEST_F(VelocityTrackerTest, SailfishFlingDownFaster3) { 686 // Sailfish - fling down - faster - 3 687 std::vector<MotionEventEntry> motions = { 688 { 235727628927000ns, {{540.00, 440.00}} }, 689 { 235727636810000ns, {{537.00, 454.00}} }, 690 { 235727646176000ns, {{536.00, 454.00}} }, 691 { 235727653586628ns, {{535.12, 456.65}} }, 692 { 235727654557000ns, {{535.00, 457.00}} }, 693 { 235727663024000ns, {{534.00, 465.00}} }, 694 { 235727670410103ns, {{533.04, 479.45}} }, 695 { 235727670691000ns, {{533.00, 480.00}} }, 696 { 235727679255000ns, {{531.00, 501.00}} }, 697 { 235727687233704ns, {{529.09, 526.73}} }, 698 { 235727687628000ns, {{529.00, 528.00}} }, 699 { 235727696113000ns, {{526.00, 558.00}} }, 700 { 235727704057546ns, {{523.18, 588.98}} }, 701 { 235727704576000ns, {{523.00, 591.00}} }, 702 { 235727713099000ns, {{520.00, 626.00}} }, 703 { 235727720880776ns, {{516.33, 655.36}} }, 704 { 235727721580000ns, {{516.00, 658.00}} }, 705 { 235727721580000ns, {{516.00, 658.00}} }, // ACTION_UP 706 }; 707 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, 4484.617676); 708 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, 4927.92627); 709 } 710 711 712 TEST_F(VelocityTrackerTest, SailfishFlingDownFast1) { 713 // Sailfish - fling down - fast - 1 714 std::vector<MotionEventEntry> motions = { 715 { 235762352849000ns, {{467.00, 286.00}} }, 716 { 235762360250000ns, {{443.00, 344.00}} }, 717 { 235762362787412ns, {{434.77, 363.89}} }, 718 { 235762368807000ns, {{438.00, 359.00}} }, 719 { 235762377220000ns, {{425.00, 423.00}} }, 720 { 235762379608561ns, {{421.31, 441.17}} }, 721 { 235762385698000ns, {{412.00, 528.00}} }, 722 { 235762394133000ns, {{406.00, 648.00}} }, 723 { 235762396429369ns, {{404.37, 680.67}} }, 724 { 235762396429369ns, {{404.37, 680.67}} }, //ACTION_UP 725 }; 726 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, 14227.0224); 727 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, 16064.685547); 728 } 729 730 731 TEST_F(VelocityTrackerTest, SailfishFlingDownFast2) { 732 // Sailfish - fling down - fast - 2 733 std::vector<MotionEventEntry> motions = { 734 { 235772487188000ns, {{576.00, 204.00}} }, 735 { 235772495159000ns, {{553.00, 236.00}} }, 736 { 235772503568000ns, {{551.00, 240.00}} }, 737 { 235772508192247ns, {{545.55, 254.17}} }, 738 { 235772512051000ns, {{541.00, 266.00}} }, 739 { 235772520794000ns, {{520.00, 337.00}} }, 740 { 235772525015263ns, {{508.92, 394.43}} }, 741 { 235772529174000ns, {{498.00, 451.00}} }, 742 { 235772537635000ns, {{484.00, 589.00}} }, 743 { 235772537635000ns, {{484.00, 589.00}} }, // ACTION_UP 744 }; 745 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, 18660.048828); 746 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, 16918.439453); 747 } 748 749 750 TEST_F(VelocityTrackerTest, SailfishFlingDownFast3) { 751 // Sailfish - fling down - fast - 3 752 std::vector<MotionEventEntry> motions = { 753 { 507650295000ns, {{628.00, 233.00}} }, 754 { 507658234000ns, {{605.00, 269.00}} }, 755 { 507666784000ns, {{601.00, 274.00}} }, 756 { 507669660483ns, {{599.65, 275.68}} }, 757 { 507675427000ns, {{582.00, 308.00}} }, 758 { 507683740000ns, {{541.00, 404.00}} }, 759 { 507686506238ns, {{527.36, 435.95}} }, 760 { 507692220000ns, {{487.00, 581.00}} }, 761 { 507700707000ns, {{454.00, 792.00}} }, 762 { 507703352649ns, {{443.71, 857.77}} }, 763 { 507703352649ns, {{443.71, 857.77}} }, // ACTION_UP 764 }; 765 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_X, -4111.8173); 766 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_X, -6388.48877); 767 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, 29765.908203); 768 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, 28354.796875); 769 } 770 771 /** 772 * ================== Multiple pointers ============================================================ 773 * 774 * Three fingers quickly tap the screen. Since this is a tap, the velocities should be zero. 775 * If the events with POINTER_UP or POINTER_DOWN are not handled correctly (these should not be 776 * part of the fitted data), this can cause large velocity values to be reported instead. 777 */ 778 TEST_F(VelocityTrackerTest, LeastSquaresVelocityTrackerStrategyEstimator_ThreeFingerTap) { 779 std::vector<MotionEventEntry> motions = { 780 { 0us, {{1063, 1128}, {NAN, NAN}, {NAN, NAN}} }, 781 { 10800us, {{1063, 1128}, {682, 1318}, {NAN, NAN}} }, // POINTER_DOWN 782 { 10800us, {{1063, 1128}, {682, 1318}, {397, 1747}} }, // POINTER_DOWN 783 { 267300us, {{1063, 1128}, {682, 1318}, {397, 1747}} }, // POINTER_UP 784 { 267300us, {{1063, 1128}, {NAN, NAN}, {397, 1747}} }, // POINTER_UP 785 { 272700us, {{1063, 1128}, {NAN, NAN}, {NAN, NAN}} }, 786 }; 787 788 // Velocity should actually be zero, but we expect 0.016 here instead. 789 // This is close enough to zero, and is likely caused by division by a very small number. 790 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_X, -0.016); 791 computeAndCheckVelocity("lsq2", motions, AMOTION_EVENT_AXIS_Y, -0.016); 792 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_X, 0); 793 computeAndCheckVelocity("impulse", motions, AMOTION_EVENT_AXIS_Y, 0); 794 } 795 796 /** 797 * ================== Tests for least squares fitting ============================================== 798 * 799 * Special care must be taken when constructing tests for LeastSquaresVelocityTrackerStrategy 800 * getEstimator function. In particular: 801 * - inside the function, time gets converted from nanoseconds to seconds 802 * before being used in the fit. 803 * - any values that are older than 100 ms are being discarded. 804 * - the newest time gets subtracted from all of the other times before being used in the fit. 805 * So these tests have to be designed with those limitations in mind. 806 * 807 * General approach for the tests below: 808 * We only used timestamps in milliseconds, 0 ms, 1 ms, and 2 ms, to be sure that 809 * we are well within the HORIZON range. 810 * When specifying the expected values of the coefficients, we treat the x values as if 811 * they were in ms. Then, to adjust for the time units, the coefficients get progressively 812 * multiplied by powers of 1E3. 813 * For example: 814 * data: t(ms), x 815 * 1 ms, 1 816 * 2 ms, 4 817 * 3 ms, 9 818 * The coefficients are (0, 0, 1). 819 * In the test, we would convert these coefficients to (0*(1E3)^0, 0*(1E3)^1, 1*(1E3)^2). 820 */ 821 TEST_F(VelocityTrackerTest, LeastSquaresVelocityTrackerStrategyEstimator_Constant) { 822 std::vector<MotionEventEntry> motions = { 823 { 0ms, {{1, 1}} }, // 0 s 824 { 1ms, {{1, 1}} }, // 0.001 s 825 { 2ms, {{1, 1}} }, // 0.002 s 826 { 2ms, {{1, 1}} }, // ACTION_UP 827 }; 828 // The data used for the fit will be as follows: 829 // time(s), position 830 // -0.002, 1 831 // -0.001, 1 832 // -0.ms, 1 833 computeAndCheckQuadraticEstimate(motions, std::array<float, 3>({1, 0, 0})); 834 } 835 836 /* 837 * Straight line y = x :: the constant and quadratic coefficients are zero. 838 */ 839 TEST_F(VelocityTrackerTest, LeastSquaresVelocityTrackerStrategyEstimator_Linear) { 840 std::vector<MotionEventEntry> motions = { 841 { 0ms, {{-2, -2}} }, 842 { 1ms, {{-1, -1}} }, 843 { 2ms, {{-0, -0}} }, 844 { 2ms, {{-0, -0}} }, // ACTION_UP 845 }; 846 // The data used for the fit will be as follows: 847 // time(s), position 848 // -0.002, -2 849 // -0.001, -1 850 // -0.000, 0 851 computeAndCheckQuadraticEstimate(motions, std::array<float, 3>({0, 1E3, 0})); 852 } 853 854 /* 855 * Parabola 856 */ 857 TEST_F(VelocityTrackerTest, LeastSquaresVelocityTrackerStrategyEstimator_Parabolic) { 858 std::vector<MotionEventEntry> motions = { 859 { 0ms, {{1, 1}} }, 860 { 1ms, {{4, 4}} }, 861 { 2ms, {{8, 8}} }, 862 { 2ms, {{8, 8}} }, // ACTION_UP 863 }; 864 // The data used for the fit will be as follows: 865 // time(s), position 866 // -0.002, 1 867 // -0.001, 4 868 // -0.000, 8 869 computeAndCheckQuadraticEstimate(motions, std::array<float, 3>({8, 4.5E3, 0.5E6})); 870 } 871 872 /* 873 * Parabola 874 */ 875 TEST_F(VelocityTrackerTest, LeastSquaresVelocityTrackerStrategyEstimator_Parabolic2) { 876 std::vector<MotionEventEntry> motions = { 877 { 0ms, {{1, 1}} }, 878 { 1ms, {{4, 4}} }, 879 { 2ms, {{9, 9}} }, 880 { 2ms, {{9, 9}} }, // ACTION_UP 881 }; 882 // The data used for the fit will be as follows: 883 // time(s), position 884 // -0.002, 1 885 // -0.001, 4 886 // -0.000, 9 887 computeAndCheckQuadraticEstimate(motions, std::array<float, 3>({9, 6E3, 1E6})); 888 } 889 890 /* 891 * Parabola :: y = x^2 :: the constant and linear coefficients are zero. 892 */ 893 TEST_F(VelocityTrackerTest, LeastSquaresVelocityTrackerStrategyEstimator_Parabolic3) { 894 std::vector<MotionEventEntry> motions = { 895 { 0ms, {{4, 4}} }, 896 { 1ms, {{1, 1}} }, 897 { 2ms, {{0, 0}} }, 898 { 2ms, {{0, 0}} }, // ACTION_UP 899 }; 900 // The data used for the fit will be as follows: 901 // time(s), position 902 // -0.002, 4 903 // -0.001, 1 904 // -0.000, 0 905 computeAndCheckQuadraticEstimate(motions, std::array<float, 3>({0, 0E3, 1E6})); 906 } 907 908 } // namespace android 909
