Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 318005c1 authored by Siarhei Vishniakou's avatar Siarhei Vishniakou
Browse files

Reset velocity for pointers that have been canceled 

To fully support palm rejection, we should not produce any velocity for
pointers that have been marked as palm.

This can be achieved by erasing the corresponding pointer state in
VelocityTracker for ACTION_POINTER_UP with FLAG_CANCELED events, or for
all pointers in ACTION_CANCEL events.

The pointers that have not been canceled will still produce the correct
velocity.

Bug: 236772648
Test: TEST=libinput_tests; m $TEST && $ANDROID_HOST_OUT/nativetest64/$TEST/$TEST
Change-Id: I67ecae6b4bff2eb63f9cff416841031dea3ed680
parent 696308f1

include/input/VelocityTracker.h

+1 −1
Original line number Diff line number Diff line
@@ -98,7 +98,7 @@ public: 
    void addMovement(nsecs_t eventTime, int32_t pointerId, int32_t axis, float position);



    // Adds movement information for all pointers in a MotionEvent, including historical samples.

    void addMovement(const MotionEvent* event);

    void addMovement(const MotionEvent& event);



    // Returns the velocity of the specified pointer id and axis in position units per second.

    // Returns empty optional if there is insufficient movement information for the pointer, or if

libs/input/VelocityTracker.cpp

+21 −10
Original line number Diff line number Diff line
@@ -275,10 +275,10 @@ void VelocityTracker::addMovement(nsecs_t eventTime, int32_t pointerId, int32_t 
    }

}



void VelocityTracker::addMovement(const MotionEvent* event) {

void VelocityTracker::addMovement(const MotionEvent& event) {

    // Stores data about which axes to process based on the incoming motion event.

    std::set<int32_t> axesToProcess;

    int32_t actionMasked = event->getActionMasked();

    int32_t actionMasked = event.getActionMasked();



    switch (actionMasked) {

        case AMOTION_EVENT_ACTION_DOWN:
@@ -291,7 +291,7 @@ void VelocityTracker::addMovement(const MotionEvent* event) { 
            // Start a new movement trace for a pointer that just went down.

            // We do this on down instead of on up because the client may want to query the

            // final velocity for a pointer that just went up.

            clearPointer(event->getPointerId(event->getActionIndex()));

            clearPointer(event.getPointerId(event.getActionIndex()));

            axesToProcess.insert(PLANAR_AXES.begin(), PLANAR_AXES.end());

            break;

        }
@@ -300,8 +300,14 @@ void VelocityTracker::addMovement(const MotionEvent* event) { 
            axesToProcess.insert(PLANAR_AXES.begin(), PLANAR_AXES.end());

            break;

        case AMOTION_EVENT_ACTION_POINTER_UP:

            if (event.getFlags() & AMOTION_EVENT_FLAG_CANCELED) {

                clearPointer(event.getPointerId(event.getActionIndex()));

                return;

            }

            // Continue to ACTION_UP to ensure that the POINTER_STOPPED logic is triggered.

            [[fallthrough]];

        case AMOTION_EVENT_ACTION_UP: {

            std::chrono::nanoseconds delaySinceLastEvent(event->getEventTime() - mLastEventTime);

            std::chrono::nanoseconds delaySinceLastEvent(event.getEventTime() - mLastEventTime);

            if (delaySinceLastEvent > ASSUME_POINTER_STOPPED_TIME) {

                ALOGD_IF(DEBUG_VELOCITY,

                         "VelocityTracker: stopped for %s, clearing state upon pointer liftoff.",
@@ -325,21 +331,26 @@ void VelocityTracker::addMovement(const MotionEvent* event) { 
        case AMOTION_EVENT_ACTION_SCROLL:

            axesToProcess.insert(AMOTION_EVENT_AXIS_SCROLL);

            break;

        case AMOTION_EVENT_ACTION_CANCEL: {

            clear();

            return;

        }



        default:

            // Ignore all other actions.

            return;

    }



    const size_t historySize = event->getHistorySize();

    const size_t historySize = event.getHistorySize();

    for (size_t h = 0; h <= historySize; h++) {

        const nsecs_t eventTime = event->getHistoricalEventTime(h);

        for (size_t i = 0; i < event->getPointerCount(); i++) {

            if (event->isResampled(i, h)) {

        const nsecs_t eventTime = event.getHistoricalEventTime(h);

        for (size_t i = 0; i < event.getPointerCount(); i++) {

            if (event.isResampled(i, h)) {

                continue; // skip resampled samples

            }

            const int32_t pointerId = event->getPointerId(i);

            const int32_t pointerId = event.getPointerId(i);

            for (int32_t axis : axesToProcess) {

                const float position = event->getHistoricalAxisValue(axis, i, h);

                const float position = event.getHistoricalAxisValue(axis, i, h);

                addMovement(eventTime, pointerId, axis, position);

            }

        }

libs/input/tests/VelocityTracker_test.cpp

+111 −43
Original line number Diff line number Diff line
@@ -229,41 +229,23 @@ static std::vector<MotionEvent> createTouchMotionEventStream( 
    return events;

}



static std::optional<float> computePlanarVelocity(

        const VelocityTracker::Strategy strategy,

        const std::vector<PlanarMotionEventEntry>& motions, int32_t axis,

static std::optional<float> computeVelocity(const VelocityTracker::Strategy strategy,

                                            const std::vector<MotionEvent>& events, int32_t axis,

                                            uint32_t pointerId = DEFAULT_POINTER_ID) {

    VelocityTracker vt(strategy);



    std::vector<MotionEvent> events = createTouchMotionEventStream(motions);

    for (MotionEvent event : events) {

        vt.addMovement(&event);

    for (const MotionEvent& event : events) {

        vt.addMovement(event);

    }



    return vt.getVelocity(axis, pointerId);

}



static std::vector<MotionEvent> createMotionEventStream(

        int32_t axis, const std::vector<std::pair<std::chrono::nanoseconds, float>>& motion) {

    switch (axis) {

        case AMOTION_EVENT_AXIS_SCROLL:

            return createAxisScrollMotionEventStream(motion);

        default:

            ADD_FAILURE() << "Axis " << axis << " is not supported";

            return {};

    }

}



static std::optional<float> computeVelocity(

static std::optional<float> computePlanarVelocity(

        const VelocityTracker::Strategy strategy,

        const std::vector<std::pair<std::chrono::nanoseconds, float>>& motions, int32_t axis) {

    VelocityTracker vt(strategy);



    for (const MotionEvent& event : createMotionEventStream(axis, motions)) {

        vt.addMovement(&event);

    }



    return vt.getVelocity(axis, DEFAULT_POINTER_ID);

        const std::vector<PlanarMotionEventEntry>& motions, int32_t axis, uint32_t pointerId) {

    std::vector<MotionEvent> events = createTouchMotionEventStream(motions);

    return computeVelocity(strategy, events, axis, pointerId);

}



static void computeAndCheckVelocity(const VelocityTracker::Strategy strategy,
@@ -277,23 +259,23 @@ static void computeAndCheckAxisScrollVelocity( 
        const VelocityTracker::Strategy strategy,

        const std::vector<std::pair<std::chrono::nanoseconds, float>>& motions,

        std::optional<float> targetVelocity) {

    checkVelocity(computeVelocity(strategy, motions, AMOTION_EVENT_AXIS_SCROLL), targetVelocity);

    std::vector<MotionEvent> events = createAxisScrollMotionEventStream(motions);

    checkVelocity(computeVelocity(strategy, events, AMOTION_EVENT_AXIS_SCROLL), targetVelocity);

    // The strategy LSQ2 is not compatible with AXIS_SCROLL. In those situations, we should fall

    // back to a strategy that supports differential axes.

    checkVelocity(computeVelocity(VelocityTracker::Strategy::LSQ2, motions,

    checkVelocity(computeVelocity(VelocityTracker::Strategy::LSQ2, events,

                                  AMOTION_EVENT_AXIS_SCROLL),

                  targetVelocity);

}



static void computeAndCheckQuadraticVelocity(const std::vector<PlanarMotionEventEntry>& motions,

                                             float velocity) {

    VelocityTracker vt(VelocityTracker::Strategy::LSQ2);

    std::vector<MotionEvent> events = createTouchMotionEventStream(motions);

    for (MotionEvent event : events) {

        vt.addMovement(&event);

    }

    std::optional<float> velocityX = vt.getVelocity(AMOTION_EVENT_AXIS_X, 0);

    std::optional<float> velocityY = vt.getVelocity(AMOTION_EVENT_AXIS_Y, 0);

    std::optional<float> velocityX =

            computePlanarVelocity(VelocityTracker::Strategy::LSQ2, motions, AMOTION_EVENT_AXIS_X,

                                  DEFAULT_POINTER_ID);

    std::optional<float> velocityY =

            computePlanarVelocity(VelocityTracker::Strategy::LSQ2, motions, AMOTION_EVENT_AXIS_Y,

                                  DEFAULT_POINTER_ID);

    ASSERT_TRUE(velocityX);

    ASSERT_TRUE(velocityY);
@@ -330,12 +312,14 @@ TEST_F(VelocityTrackerTest, TestDefaultStrategiesForPlanarAxes) { 
                                                   {30ms, {{6, 20}}},

                                                   {40ms, {{10, 30}}}};



    EXPECT_EQ(computePlanarVelocity(VelocityTracker::Strategy::LSQ2, motions, AMOTION_EVENT_AXIS_X),

    EXPECT_EQ(computePlanarVelocity(VelocityTracker::Strategy::LSQ2, motions, AMOTION_EVENT_AXIS_X,

                                    DEFAULT_POINTER_ID),

              computePlanarVelocity(VelocityTracker::Strategy::DEFAULT, motions,

                                    AMOTION_EVENT_AXIS_X));

    EXPECT_EQ(computePlanarVelocity(VelocityTracker::Strategy::LSQ2, motions, AMOTION_EVENT_AXIS_Y),

                                    AMOTION_EVENT_AXIS_X, DEFAULT_POINTER_ID));

    EXPECT_EQ(computePlanarVelocity(VelocityTracker::Strategy::LSQ2, motions, AMOTION_EVENT_AXIS_Y,

                                    DEFAULT_POINTER_ID),

              computePlanarVelocity(VelocityTracker::Strategy::DEFAULT, motions,

                                    AMOTION_EVENT_AXIS_Y));

                                    AMOTION_EVENT_AXIS_Y, DEFAULT_POINTER_ID));

}



TEST_F(VelocityTrackerTest, TestComputedVelocity) {
@@ -431,7 +415,7 @@ TEST_F(VelocityTrackerTest, TestGetComputedVelocity) { 
    VelocityTracker vt(VelocityTracker::Strategy::IMPULSE);

    std::vector<MotionEvent> events = createTouchMotionEventStream(motions);

    for (const MotionEvent& event : events) {

        vt.addMovement(&event);

        vt.addMovement(event);

    }



    float maxFloat = std::numeric_limits<float>::max();
@@ -509,6 +493,89 @@ TEST_F(VelocityTrackerTest, ThreePointsLinearVelocityTest) { 
    computeAndCheckVelocity(VelocityTracker::Strategy::LSQ2, motions, AMOTION_EVENT_AXIS_X, 500);

}



/**

 * When the stream is terminated with ACTION_CANCEL, the resulting velocity should be 0.

 */

TEST_F(VelocityTrackerTest, ActionCancelResultsInZeroVelocity) {

    std::vector<PlanarMotionEventEntry> motions = {

            {0ms, {{0, 0}}},    // DOWN

            {10ms, {{5, 10}}},  // MOVE

            {20ms, {{10, 20}}}, // MOVE

            {20ms, {{10, 20}}}, // ACTION_UP

    };

    std::vector<MotionEvent> events = createTouchMotionEventStream(motions);

    // By default, `createTouchMotionEventStream` produces an event stream that terminates with

    // ACTION_UP. We need to manually change it to ACTION_CANCEL.

    MotionEvent& lastEvent = events.back();

    lastEvent.setAction(AMOTION_EVENT_ACTION_CANCEL);

    lastEvent.setFlags(lastEvent.getFlags() | AMOTION_EVENT_FLAG_CANCELED);

    const int32_t pointerId = lastEvent.getPointerId(0);

    checkVelocity(computeVelocity(VelocityTracker::Strategy::IMPULSE, events, AMOTION_EVENT_AXIS_X,

                                  pointerId),

                  /*targetVelocity*/ std::nullopt);

    checkVelocity(computeVelocity(VelocityTracker::Strategy::IMPULSE, events, AMOTION_EVENT_AXIS_Y,

                                  pointerId),

                  /*targetVelocity*/ std::nullopt);

    checkVelocity(computeVelocity(VelocityTracker::Strategy::LSQ2, events, AMOTION_EVENT_AXIS_X,

                                  pointerId),

                  /*targetVelocity*/ std::nullopt);

    checkVelocity(computeVelocity(VelocityTracker::Strategy::LSQ2, events, AMOTION_EVENT_AXIS_Y,

                                  pointerId),

                  /*targetVelocity*/ std::nullopt);

}



/**

 * When the stream is terminated with ACTION_CANCEL, the resulting velocity should be 0.

 */

TEST_F(VelocityTrackerTest, ActionPointerCancelResultsInZeroVelocityForThatPointer) {

    std::vector<PlanarMotionEventEntry> motions = {

            {0ms, {{0, 5}, {NAN, NAN}}},    // DOWN

            {0ms, {{0, 5}, {10, 15}}},      // POINTER_DOWN

            {10ms, {{5, 10}, {15, 20}}},    // MOVE

            {20ms, {{10, 15}, {20, 25}}},   // MOVE

            {30ms, {{10, 15}, {20, 25}}},   // POINTER_UP

            {30ms, {{10, 15}, {NAN, NAN}}}, // UP

    };

    std::vector<MotionEvent> events = createTouchMotionEventStream(motions);

    // Cancel the lifting pointer of the ACTION_POINTER_UP event

    MotionEvent& pointerUpEvent = events.rbegin()[1];

    pointerUpEvent.setFlags(pointerUpEvent.getFlags() | AMOTION_EVENT_FLAG_CANCELED);

    const int32_t pointerId = pointerUpEvent.getPointerId(pointerUpEvent.getActionIndex());

    // Double check the stream

    ASSERT_EQ(1, pointerId);

    ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_UP, pointerUpEvent.getActionMasked());

    ASSERT_EQ(AMOTION_EVENT_ACTION_UP, events.back().getActionMasked());



    // Ensure the velocity of the lifting pointer is zero

    checkVelocity(computeVelocity(VelocityTracker::Strategy::IMPULSE, events, AMOTION_EVENT_AXIS_X,

                                  pointerId),

                  /*targetVelocity*/ std::nullopt);

    checkVelocity(computeVelocity(VelocityTracker::Strategy::IMPULSE, events, AMOTION_EVENT_AXIS_Y,

                                  pointerId),

                  /*targetVelocity*/ std::nullopt);

    checkVelocity(computeVelocity(VelocityTracker::Strategy::LSQ2, events, AMOTION_EVENT_AXIS_X,

                                  pointerId),

                  /*targetVelocity*/ std::nullopt);

    checkVelocity(computeVelocity(VelocityTracker::Strategy::LSQ2, events, AMOTION_EVENT_AXIS_Y,

                                  pointerId),

                  /*targetVelocity*/ std::nullopt);



    // The remaining pointer should have the correct velocity.

    const int32_t remainingPointerId = events.back().getPointerId(0);

    ASSERT_EQ(0, remainingPointerId);

    checkVelocity(computeVelocity(VelocityTracker::Strategy::IMPULSE, events, AMOTION_EVENT_AXIS_X,

                                  remainingPointerId),

                  /*targetVelocity*/ 500);

    checkVelocity(computeVelocity(VelocityTracker::Strategy::IMPULSE, events, AMOTION_EVENT_AXIS_Y,

                                  remainingPointerId),

                  /*targetVelocity*/ 500);

    checkVelocity(computeVelocity(VelocityTracker::Strategy::LSQ2, events, AMOTION_EVENT_AXIS_X,

                                  remainingPointerId),

                  /*targetVelocity*/ 500);

    checkVelocity(computeVelocity(VelocityTracker::Strategy::LSQ2, events, AMOTION_EVENT_AXIS_Y,

                                  remainingPointerId),

                  /*targetVelocity*/ 500);

}



/**

 * ================== VelocityTracker tests generated by recording real events =====================
@@ -1336,9 +1403,10 @@ TEST_F(VelocityTrackerTest, TestDefaultStrategyForAxisScroll) { 
            {40ms, 100},

    };



    EXPECT_EQ(computeVelocity(VelocityTracker::Strategy::IMPULSE, motions,

    std::vector<MotionEvent> events = createAxisScrollMotionEventStream(motions);

    EXPECT_EQ(computeVelocity(VelocityTracker::Strategy::IMPULSE, events,

                              AMOTION_EVENT_AXIS_SCROLL),

              computeVelocity(VelocityTracker::Strategy::DEFAULT, motions,

              computeVelocity(VelocityTracker::Strategy::DEFAULT, events,

                              AMOTION_EVENT_AXIS_SCROLL));

}