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

Commit 23c8dff7 authored by Harry Cutts's avatar Harry Cutts
Browse files

CapturedTouchpadEventConverter: fix button reporting 

The previous implementation had a couple of issues with reporting
BUTTON_PRESS or _RELEASE events with no pointers, which are invalid.
This occurred when the evdev device reported a button press one sync
before reporting a touch going down (observed when tapping hard and fast
on an Apple Magic Trackpad 2), or when the last touch lifted in the same
evdev sync as the button being released.

Bug: b/281825527
Test: atest inputflinger_tests
Test: manual checking of events reported to a test app capturing the pad
Change-Id: I1676a1ab9281872c745416ad41186c65a44eb581
parent bd65cc20

services/inputflinger/reader/mapper/CapturedTouchpadEventConverter.cpp

+23 −5
Original line number Diff line number Diff line
@@ -199,6 +199,29 @@ std::list<NotifyArgs> CapturedTouchpadEventConverter::sync(nsecs_t when, nsecs_t 
        }

    }



    // Send BUTTON_RELEASE events. (This has to happen before any UP events to avoid sending

    // BUTTON_RELEASE events without any pointers.)

    uint32_t newButtonState;

    if (coords.size() - upSlots.size() + downSlots.size() == 0) {

        // If there won't be any pointers down after this evdev sync, we won't be able to send

        // button updates on their own, as motion events without pointers are invalid. To avoid

        // erroneously reporting buttons being held for long periods, send BUTTON_RELEASE events for

        // all pressed buttons when the last pointer is lifted.

        //

        // This also prevents us from sending BUTTON_PRESS events too early in the case of touchpads

        // which report a button press one evdev sync before reporting a touch going down.

        newButtonState = 0;

    } else {

        newButtonState = mCursorButtonAccumulator.getButtonState();

    }

    for (uint32_t button = 1; button <= AMOTION_EVENT_BUTTON_FORWARD; button <<= 1) {

        if (!(newButtonState & button) && mButtonState & button) {

            mButtonState &= ~button;

            out.push_back(makeMotionArgs(when, readTime, AMOTION_EVENT_ACTION_BUTTON_RELEASE,

                                         coords, properties, /*actionButton=*/button));

        }

    }



    // For any touches that were lifted, send UP or POINTER_UP events.

    for (size_t slotNumber : upSlots) {

        const size_t indexToRemove = coordsIndexForSlotNumber.at(slotNumber);
@@ -240,16 +263,11 @@ std::list<NotifyArgs> CapturedTouchpadEventConverter::sync(nsecs_t when, nsecs_t 
        out.push_back(makeMotionArgs(when, readTime, action, coords, properties));

    }



    const uint32_t newButtonState = mCursorButtonAccumulator.getButtonState();

    for (uint32_t button = 1; button <= AMOTION_EVENT_BUTTON_FORWARD; button <<= 1) {

        if (newButtonState & button && !(mButtonState & button)) {

            mButtonState |= button;

            out.push_back(makeMotionArgs(when, readTime, AMOTION_EVENT_ACTION_BUTTON_PRESS, coords,

                                         properties, /*actionButton=*/button));

        } else if (!(newButtonState & button) && mButtonState & button) {

            mButtonState &= ~button;

            out.push_back(makeMotionArgs(when, readTime, AMOTION_EVENT_ACTION_BUTTON_RELEASE,

                                         coords, properties, /*actionButton=*/button));

        }

    }

    return out;

services/inputflinger/tests/CapturedTouchpadEventConverter_test.cpp

+171 −0
Original line number Diff line number Diff line
@@ -781,4 +781,175 @@ TEST_F(CapturedTouchpadEventConverterTest, PointerIdsReusedAfterLift) { 
                      WithPointerId(/*index=*/1, /*id=*/0)));

}



// Motion events without any pointers are invalid, so when a button press is reported in the same

// frame as a touch down, the button press must be reported second. Similarly with a button release

// and a touch lift.

TEST_F(CapturedTouchpadEventConverterTest,

       ButtonPressedAndReleasedInSameFrameAsTouch_ReportedWithPointers) {

    CapturedTouchpadEventConverter conv = createConverter();



    processAxis(conv, EV_ABS, ABS_MT_SLOT, 0);

    processAxis(conv, EV_ABS, ABS_MT_TRACKING_ID, 1);

    processAxis(conv, EV_ABS, ABS_MT_POSITION_X, 50);

    processAxis(conv, EV_ABS, ABS_MT_POSITION_Y, 100);

    processAxis(conv, EV_KEY, BTN_TOUCH, 1);

    processAxis(conv, EV_KEY, BTN_TOOL_FINGER, 1);



    processAxis(conv, EV_KEY, BTN_LEFT, 1);



    std::list<NotifyArgs> args = processSync(conv);

    ASSERT_EQ(2u, args.size());

    EXPECT_THAT(std::get<NotifyMotionArgs>(args.front()),

                WithMotionAction(AMOTION_EVENT_ACTION_DOWN));

    args.pop_front();

    EXPECT_THAT(std::get<NotifyMotionArgs>(args.front()),

                AllOf(WithMotionAction(AMOTION_EVENT_ACTION_BUTTON_PRESS), WithPointerCount(1u),

                      WithCoords(50, 100), WithActionButton(AMOTION_EVENT_BUTTON_PRIMARY),

                      WithButtonState(AMOTION_EVENT_BUTTON_PRIMARY)));



    processAxis(conv, EV_ABS, ABS_MT_TRACKING_ID, -1);

    processAxis(conv, EV_KEY, BTN_TOUCH, 0);

    processAxis(conv, EV_KEY, BTN_TOOL_FINGER, 0);



    processAxis(conv, EV_KEY, BTN_LEFT, 0);

    args = processSync(conv);

    ASSERT_EQ(3u, args.size());

    EXPECT_THAT(std::get<NotifyMotionArgs>(args.front()),

                WithMotionAction(AMOTION_EVENT_ACTION_MOVE));

    args.pop_front();

    EXPECT_THAT(std::get<NotifyMotionArgs>(args.front()),

                AllOf(WithMotionAction(AMOTION_EVENT_ACTION_BUTTON_RELEASE), WithPointerCount(1u),

                      WithCoords(50, 100), WithActionButton(AMOTION_EVENT_BUTTON_PRIMARY),

                      WithButtonState(0)));

    args.pop_front();

    EXPECT_THAT(std::get<NotifyMotionArgs>(args.front()),

                WithMotionAction(AMOTION_EVENT_ACTION_UP));

}



// Some touchpads sometimes report a button press before they report the finger touching the pad. In

// that case we need to wait until the touch comes to report the button press.

TEST_F(CapturedTouchpadEventConverterTest, ButtonPressedBeforeTouch_ReportedOnceTouchOccurs) {

    CapturedTouchpadEventConverter conv = createConverter();



    processAxis(conv, EV_KEY, BTN_LEFT, 1);

    ASSERT_EQ(0u, processSync(conv).size());



    processAxis(conv, EV_ABS, ABS_MT_SLOT, 0);

    processAxis(conv, EV_ABS, ABS_MT_TRACKING_ID, 1);

    processAxis(conv, EV_ABS, ABS_MT_POSITION_X, 50);

    processAxis(conv, EV_ABS, ABS_MT_POSITION_Y, 100);

    processAxis(conv, EV_KEY, BTN_TOUCH, 1);

    processAxis(conv, EV_KEY, BTN_TOOL_FINGER, 1);



    std::list<NotifyArgs> args = processSync(conv);

    ASSERT_EQ(2u, args.size());

    EXPECT_THAT(std::get<NotifyMotionArgs>(args.front()),

                WithMotionAction(AMOTION_EVENT_ACTION_DOWN));

    args.pop_front();

    EXPECT_THAT(std::get<NotifyMotionArgs>(args.front()),

                AllOf(WithMotionAction(AMOTION_EVENT_ACTION_BUTTON_PRESS), WithPointerCount(1u),

                      WithCoords(50, 100), WithActionButton(AMOTION_EVENT_BUTTON_PRIMARY),

                      WithButtonState(AMOTION_EVENT_BUTTON_PRIMARY)));

}



// When all fingers are lifted from a touchpad, we should release any buttons that are down, since

// we won't be able to report them being lifted later if no pointers are present.

TEST_F(CapturedTouchpadEventConverterTest, ButtonReleasedAfterTouchLifts_ReportedWithLift) {

    CapturedTouchpadEventConverter conv = createConverter();



    processAxis(conv, EV_ABS, ABS_MT_SLOT, 0);

    processAxis(conv, EV_ABS, ABS_MT_TRACKING_ID, 1);

    processAxis(conv, EV_ABS, ABS_MT_POSITION_X, 50);

    processAxis(conv, EV_ABS, ABS_MT_POSITION_Y, 100);

    processAxis(conv, EV_KEY, BTN_TOUCH, 1);

    processAxis(conv, EV_KEY, BTN_TOOL_FINGER, 1);



    processAxis(conv, EV_KEY, BTN_LEFT, 1);



    std::list<NotifyArgs> args = processSync(conv);

    ASSERT_EQ(2u, args.size());

    EXPECT_THAT(std::get<NotifyMotionArgs>(args.front()),

                WithMotionAction(AMOTION_EVENT_ACTION_DOWN));

    args.pop_front();

    EXPECT_THAT(std::get<NotifyMotionArgs>(args.front()),

                WithMotionAction(AMOTION_EVENT_ACTION_BUTTON_PRESS));



    processAxis(conv, EV_ABS, ABS_MT_TRACKING_ID, -1);

    processAxis(conv, EV_KEY, BTN_TOUCH, 0);

    processAxis(conv, EV_KEY, BTN_TOOL_FINGER, 0);

    args = processSync(conv);

    ASSERT_EQ(3u, args.size());

    EXPECT_THAT(std::get<NotifyMotionArgs>(args.front()),

                WithMotionAction(AMOTION_EVENT_ACTION_MOVE));

    args.pop_front();

    EXPECT_THAT(std::get<NotifyMotionArgs>(args.front()),

                AllOf(WithMotionAction(AMOTION_EVENT_ACTION_BUTTON_RELEASE), WithPointerCount(1u),

                      WithCoords(50, 100), WithActionButton(AMOTION_EVENT_BUTTON_PRIMARY),

                      WithButtonState(0)));

    args.pop_front();

    EXPECT_THAT(std::get<NotifyMotionArgs>(args.front()),

                WithMotionAction(AMOTION_EVENT_ACTION_UP));



    processAxis(conv, EV_KEY, BTN_LEFT, 0);

    ASSERT_EQ(0u, processSync(conv).size());

}



TEST_F(CapturedTouchpadEventConverterTest, MultipleButtonsPressedDuringTouch_ReportedCorrectly) {

    CapturedTouchpadEventConverter conv = createConverter();



    processAxis(conv, EV_ABS, ABS_MT_SLOT, 0);

    processAxis(conv, EV_ABS, ABS_MT_TRACKING_ID, 1);

    processAxis(conv, EV_ABS, ABS_MT_POSITION_X, 50);

    processAxis(conv, EV_ABS, ABS_MT_POSITION_Y, 100);

    processAxis(conv, EV_KEY, BTN_TOUCH, 1);

    processAxis(conv, EV_KEY, BTN_TOOL_FINGER, 1);



    EXPECT_THAT(processSyncAndExpectSingleMotionArg(conv),

                WithMotionAction(AMOTION_EVENT_ACTION_DOWN));



    processAxis(conv, EV_KEY, BTN_LEFT, 1);

    std::list<NotifyArgs> args = processSync(conv);

    ASSERT_EQ(2u, args.size());

    EXPECT_THAT(std::get<NotifyMotionArgs>(args.front()),

                WithMotionAction(AMOTION_EVENT_ACTION_MOVE));

    args.pop_front();

    EXPECT_THAT(std::get<NotifyMotionArgs>(args.front()),

                AllOf(WithMotionAction(AMOTION_EVENT_ACTION_BUTTON_PRESS),

                      WithActionButton(AMOTION_EVENT_BUTTON_PRIMARY),

                      WithButtonState(AMOTION_EVENT_BUTTON_PRIMARY)));



    processAxis(conv, EV_KEY, BTN_RIGHT, 1);

    args = processSync(conv);

    ASSERT_EQ(2u, args.size());

    EXPECT_THAT(std::get<NotifyMotionArgs>(args.front()),

                WithMotionAction(AMOTION_EVENT_ACTION_MOVE));

    args.pop_front();

    EXPECT_THAT(std::get<NotifyMotionArgs>(args.front()),

                AllOf(WithMotionAction(AMOTION_EVENT_ACTION_BUTTON_PRESS),

                      WithActionButton(AMOTION_EVENT_BUTTON_SECONDARY),

                      WithButtonState(AMOTION_EVENT_BUTTON_PRIMARY |

                                      AMOTION_EVENT_BUTTON_SECONDARY)));



    processAxis(conv, EV_KEY, BTN_LEFT, 0);

    args = processSync(conv);

    ASSERT_EQ(2u, args.size());

    EXPECT_THAT(std::get<NotifyMotionArgs>(args.front()),

                WithMotionAction(AMOTION_EVENT_ACTION_MOVE));

    args.pop_front();

    EXPECT_THAT(std::get<NotifyMotionArgs>(args.front()),

                AllOf(WithMotionAction(AMOTION_EVENT_ACTION_BUTTON_RELEASE),

                      WithActionButton(AMOTION_EVENT_BUTTON_PRIMARY),

                      WithButtonState(AMOTION_EVENT_BUTTON_SECONDARY)));



    processAxis(conv, EV_KEY, BTN_RIGHT, 0);

    args = processSync(conv);

    ASSERT_EQ(2u, args.size());

    EXPECT_THAT(std::get<NotifyMotionArgs>(args.front()),

                WithMotionAction(AMOTION_EVENT_ACTION_MOVE));

    args.pop_front();

    EXPECT_THAT(std::get<NotifyMotionArgs>(args.front()),

                AllOf(WithMotionAction(AMOTION_EVENT_ACTION_BUTTON_RELEASE),

                      WithActionButton(AMOTION_EVENT_BUTTON_SECONDARY), WithButtonState(0)));

}



} // namespace android