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

Commit 5abcceaf authored by Harry Cutts's avatar Harry Cutts Committed by Automerger Merge Worker
Browse files

Merge "Reset fingers and buttons in GestureConverter::reset" into udc-dev am: c4ddd876 

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/native/+/22160160



Change-Id: I332b525c3e967a1e006a96f516620da52ae3cb66
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents b9f1bcbd c4ddd876

services/inputflinger/reader/mapper/TouchpadInputMapper.cpp

+3 −2
Original line number Original line Diff line number Diff line
@@ -256,8 +256,9 @@ std::list<NotifyArgs> TouchpadInputMapper::configure(nsecs_t when, 




std::list<NotifyArgs> TouchpadInputMapper::reset(nsecs_t when) {

std::list<NotifyArgs> TouchpadInputMapper::reset(nsecs_t when) {

    mStateConverter.reset();

    mStateConverter.reset();

    mGestureConverter.reset();

    std::list<NotifyArgs> out = mGestureConverter.reset(when);

    return InputMapper::reset(when);

    out += InputMapper::reset(when);

    return out;

}

}





std::list<NotifyArgs> TouchpadInputMapper::process(const RawEvent* rawEvent) {

std::list<NotifyArgs> TouchpadInputMapper::process(const RawEvent* rawEvent) {

services/inputflinger/reader/mapper/gestures/GestureConverter.cpp

+85 −19
Original line number Original line Diff line number Diff line
@@ -72,8 +72,32 @@ std::string GestureConverter::dump() const { 
    return out.str();

    return out.str();

}

}





void GestureConverter::reset() {

std::list<NotifyArgs> GestureConverter::reset(nsecs_t when) {

    mButtonState = 0;

    std::list<NotifyArgs> out;

    switch (mCurrentClassification) {

        case MotionClassification::TWO_FINGER_SWIPE:

            out.push_back(endScroll(when, when));

            break;

        case MotionClassification::MULTI_FINGER_SWIPE:

            out += handleMultiFingerSwipeLift(when, when);

            break;

        case MotionClassification::PINCH:

            out += endPinch(when, when);

            break;

        case MotionClassification::NONE:

            // When a button is pressed, the Gestures library always ends the current gesture,

            // so we don't have to worry about the case where buttons need to be lifted during a

            // pinch or swipe.

            if (mButtonState) {

                out += releaseAllButtons(when, when);

            }

            break;

        default:

            break;

    }

    mCurrentClassification = MotionClassification::NONE;

    mDownTime = 0;

    return out;

}

}





void GestureConverter::populateMotionRanges(InputDeviceInfo& info) const {

void GestureConverter::populateMotionRanges(InputDeviceInfo& info) const {
@@ -219,6 +243,39 @@ std::list<NotifyArgs> GestureConverter::handleButtonsChange(nsecs_t when, nsecs_ 
    return out;

    return out;

}

}





std::list<NotifyArgs> GestureConverter::releaseAllButtons(nsecs_t when, nsecs_t readTime) {

    std::list<NotifyArgs> out;

    const auto [xCursorPosition, yCursorPosition] = mPointerController->getPosition();



    PointerCoords coords;

    coords.clear();

    coords.setAxisValue(AMOTION_EVENT_AXIS_X, xCursorPosition);

    coords.setAxisValue(AMOTION_EVENT_AXIS_Y, yCursorPosition);

    coords.setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, 0);

    coords.setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, 0);

    const bool pointerDown = isPointerDown(mButtonState);

    coords.setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, pointerDown ? 1.0f : 0.0f);

    uint32_t newButtonState = mButtonState;

    for (uint32_t button = AMOTION_EVENT_BUTTON_PRIMARY; button <= AMOTION_EVENT_BUTTON_FORWARD;

         button <<= 1) {

        if (mButtonState & button) {

            newButtonState &= ~button;

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

                                         button, newButtonState, /*pointerCount=*/1,

                                         mFingerProps.data(), &coords, xCursorPosition,

                                         yCursorPosition));

        }

    }

    if (pointerDown) {

        coords.setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 0.0f);

        out.push_back(makeMotionArgs(when, readTime, AMOTION_EVENT_ACTION_UP, /*actionButton=*/0,

                                     newButtonState, /*pointerCount=*/1, mFingerProps.data(),

                                     &coords, xCursorPosition, yCursorPosition));

    }

    mButtonState = 0;

    return out;

}



std::list<NotifyArgs> GestureConverter::handleScroll(nsecs_t when, nsecs_t readTime,

std::list<NotifyArgs> GestureConverter::handleScroll(nsecs_t when, nsecs_t readTime,

                                                     const Gesture& gesture) {

                                                     const Gesture& gesture) {

    std::list<NotifyArgs> out;

    std::list<NotifyArgs> out;
@@ -264,6 +321,10 @@ NotifyArgs GestureConverter::handleFling(nsecs_t when, nsecs_t readTime, const G 
        return {};

        return {};

    }

    }





    return endScroll(when, readTime);

}



NotifyArgs GestureConverter::endScroll(nsecs_t when, nsecs_t readTime) {

    const auto [xCursorPosition, yCursorPosition] = mPointerController->getPosition();

    const auto [xCursorPosition, yCursorPosition] = mPointerController->getPosition();

    mFakeFingerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_GESTURE_SCROLL_X_DISTANCE, 0);

    mFakeFingerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_GESTURE_SCROLL_X_DISTANCE, 0);

    mFakeFingerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_GESTURE_SCROLL_Y_DISTANCE, 0);

    mFakeFingerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_GESTURE_SCROLL_Y_DISTANCE, 0);
@@ -366,8 +427,6 @@ NotifyArgs GestureConverter::handleFling(nsecs_t when, nsecs_t readTime, const G 




[[nodiscard]] std::list<NotifyArgs> GestureConverter::handlePinch(nsecs_t when, nsecs_t readTime,

[[nodiscard]] std::list<NotifyArgs> GestureConverter::handlePinch(nsecs_t when, nsecs_t readTime,

                                                                  const Gesture& gesture) {

                                                                  const Gesture& gesture) {

    std::list<NotifyArgs> out;



    const auto [xCursorPosition, yCursorPosition] = mPointerController->getPosition();

    const auto [xCursorPosition, yCursorPosition] = mPointerController->getPosition();





    // Pinch gesture phases are reported a little differently from others, in that the same details

    // Pinch gesture phases are reported a little differently from others, in that the same details
@@ -391,6 +450,7 @@ NotifyArgs GestureConverter::handleFling(nsecs_t when, nsecs_t readTime, const G 
        mFakeFingerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_Y, yCursorPosition);

        mFakeFingerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_Y, yCursorPosition);

        mFakeFingerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 1.0f);

        mFakeFingerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 1.0f);

        mDownTime = when;

        mDownTime = when;

        std::list<NotifyArgs> out;

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

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

                                     /* actionButton= */ 0, mButtonState, /* pointerCount= */ 1,

                                     /* actionButton= */ 0, mButtonState, /* pointerCount= */ 1,

                                     mFingerProps.data(), mFakeFingerCoords.data(), xCursorPosition,

                                     mFingerProps.data(), mFakeFingerCoords.data(), xCursorPosition,
@@ -405,19 +465,7 @@ NotifyArgs GestureConverter::handleFling(nsecs_t when, nsecs_t readTime, const G 
    }

    }





    if (gesture.details.pinch.zoom_state == GESTURES_ZOOM_END) {

    if (gesture.details.pinch.zoom_state == GESTURES_ZOOM_END) {

        mFakeFingerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_GESTURE_PINCH_SCALE_FACTOR, 1.0);

        return endPinch(when, readTime);

        out.push_back(makeMotionArgs(when, readTime,

                                     AMOTION_EVENT_ACTION_POINTER_UP |

                                             1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT,

                                     /* actionButton= */ 0, mButtonState, /* pointerCount= */ 2,

                                     mFingerProps.data(), mFakeFingerCoords.data(), xCursorPosition,

                                     yCursorPosition));

        out.push_back(makeMotionArgs(when, readTime, AMOTION_EVENT_ACTION_UP, /* actionButton= */ 0,

                                     mButtonState, /* pointerCount= */ 1, mFingerProps.data(),

                                     mFakeFingerCoords.data(), xCursorPosition, yCursorPosition));

        mCurrentClassification = MotionClassification::NONE;

        mFakeFingerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_GESTURE_PINCH_SCALE_FACTOR, 0);

        return out;

    }

    }





    mPinchFingerSeparation *= gesture.details.pinch.dz;

    mPinchFingerSeparation *= gesture.details.pinch.dz;
@@ -429,9 +477,27 @@ NotifyArgs GestureConverter::handleFling(nsecs_t when, nsecs_t readTime, const G 
    mFakeFingerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_X,

    mFakeFingerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_X,

                                      xCursorPosition + mPinchFingerSeparation / 2);

                                      xCursorPosition + mPinchFingerSeparation / 2);

    mFakeFingerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_Y, yCursorPosition);

    mFakeFingerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_Y, yCursorPosition);

    out.push_back(makeMotionArgs(when, readTime, AMOTION_EVENT_ACTION_MOVE, /* actionButton= */ 0,

    return {makeMotionArgs(when, readTime, AMOTION_EVENT_ACTION_MOVE, /*actionButton=*/0,

                           mButtonState, /*pointerCount=*/2, mFingerProps.data(),

                           mButtonState, /*pointerCount=*/2, mFingerProps.data(),

                           mFakeFingerCoords.data(), xCursorPosition, yCursorPosition)};

}



std::list<NotifyArgs> GestureConverter::endPinch(nsecs_t when, nsecs_t readTime) {

    std::list<NotifyArgs> out;

    const auto [xCursorPosition, yCursorPosition] = mPointerController->getPosition();



    mFakeFingerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_GESTURE_PINCH_SCALE_FACTOR, 1.0);

    out.push_back(makeMotionArgs(when, readTime,

                                 AMOTION_EVENT_ACTION_POINTER_UP |

                                         1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT,

                                 /*actionButton=*/0, mButtonState, /*pointerCount=*/2,

                                 mFingerProps.data(), mFakeFingerCoords.data(), xCursorPosition,

                                 yCursorPosition));

    out.push_back(makeMotionArgs(when, readTime, AMOTION_EVENT_ACTION_UP, /*actionButton=*/0,

                                 mButtonState, /*pointerCount=*/1, mFingerProps.data(),

                                 mFakeFingerCoords.data(), xCursorPosition, yCursorPosition));

                                 mFakeFingerCoords.data(), xCursorPosition, yCursorPosition));

    mCurrentClassification = MotionClassification::NONE;

    mFakeFingerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_GESTURE_PINCH_SCALE_FACTOR, 0);

    return out;

    return out;

}

}

services/inputflinger/reader/mapper/gestures/GestureConverter.h

+5 −1
Original line number Original line Diff line number Diff line
@@ -44,7 +44,7 @@ public: 
    std::string dump() const;

    std::string dump() const;





    void setOrientation(ui::Rotation orientation) { mOrientation = orientation; }

    void setOrientation(ui::Rotation orientation) { mOrientation = orientation; }

    void reset();

    [[nodiscard]] std::list<NotifyArgs> reset(nsecs_t when);





    void populateMotionRanges(InputDeviceInfo& info) const;

    void populateMotionRanges(InputDeviceInfo& info) const;
@@ -55,15 +55,19 @@ private: 
    [[nodiscard]] NotifyArgs handleMove(nsecs_t when, nsecs_t readTime, const Gesture& gesture);

    [[nodiscard]] NotifyArgs handleMove(nsecs_t when, nsecs_t readTime, const Gesture& gesture);

    [[nodiscard]] std::list<NotifyArgs> handleButtonsChange(nsecs_t when, nsecs_t readTime,

    [[nodiscard]] std::list<NotifyArgs> handleButtonsChange(nsecs_t when, nsecs_t readTime,

                                                            const Gesture& gesture);

                                                            const Gesture& gesture);

    [[nodiscard]] std::list<NotifyArgs> releaseAllButtons(nsecs_t when, nsecs_t readTime);

    [[nodiscard]] std::list<NotifyArgs> handleScroll(nsecs_t when, nsecs_t readTime,

    [[nodiscard]] std::list<NotifyArgs> handleScroll(nsecs_t when, nsecs_t readTime,

                                                     const Gesture& gesture);

                                                     const Gesture& gesture);

    [[nodiscard]] NotifyArgs handleFling(nsecs_t when, nsecs_t readTime, const Gesture& gesture);

    [[nodiscard]] NotifyArgs handleFling(nsecs_t when, nsecs_t readTime, const Gesture& gesture);

    [[nodiscard]] NotifyArgs endScroll(nsecs_t when, nsecs_t readTime);



    [[nodiscard]] std::list<NotifyArgs> handleMultiFingerSwipe(nsecs_t when, nsecs_t readTime,

    [[nodiscard]] std::list<NotifyArgs> handleMultiFingerSwipe(nsecs_t when, nsecs_t readTime,

                                                               uint32_t fingerCount, float dx,

                                                               uint32_t fingerCount, float dx,

                                                               float dy);

                                                               float dy);

    [[nodiscard]] std::list<NotifyArgs> handleMultiFingerSwipeLift(nsecs_t when, nsecs_t readTime);

    [[nodiscard]] std::list<NotifyArgs> handleMultiFingerSwipeLift(nsecs_t when, nsecs_t readTime);

    [[nodiscard]] std::list<NotifyArgs> handlePinch(nsecs_t when, nsecs_t readTime,

    [[nodiscard]] std::list<NotifyArgs> handlePinch(nsecs_t when, nsecs_t readTime,

                                                    const Gesture& gesture);

                                                    const Gesture& gesture);

    [[nodiscard]] std::list<NotifyArgs> endPinch(nsecs_t when, nsecs_t readTime);





    NotifyMotionArgs makeMotionArgs(nsecs_t when, nsecs_t readTime, int32_t action,

    NotifyMotionArgs makeMotionArgs(nsecs_t when, nsecs_t readTime, int32_t action,

                                    int32_t actionButton, int32_t buttonState,

                                    int32_t actionButton, int32_t buttonState,

services/inputflinger/tests/GestureConverter_test.cpp

+103 −0
Original line number Original line Diff line number Diff line
@@ -785,4 +785,107 @@ TEST_F(GestureConverterTest, Pinch_ClearsClassificationAndScaleFactorAfterGestur 
                      WithGesturePinchScaleFactor(0, EPSILON)));

                      WithGesturePinchScaleFactor(0, EPSILON)));

}

}





TEST_F(GestureConverterTest, ResetWithButtonPressed) {

    InputDeviceContext deviceContext(*mDevice, EVENTHUB_ID);

    GestureConverter converter(*mReader->getContext(), deviceContext, DEVICE_ID);



    Gesture downGesture(kGestureButtonsChange, ARBITRARY_GESTURE_TIME, ARBITRARY_GESTURE_TIME,

                        /*down=*/GESTURES_BUTTON_LEFT | GESTURES_BUTTON_RIGHT,

                        /*up=*/GESTURES_BUTTON_NONE, /*is_tap=*/false);

    (void)converter.handleGesture(ARBITRARY_TIME, READ_TIME, downGesture);



    std::list<NotifyArgs> args = converter.reset(ARBITRARY_TIME);

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



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

                AllOf(WithMotionAction(AMOTION_EVENT_ACTION_BUTTON_RELEASE),

                      WithActionButton(AMOTION_EVENT_BUTTON_PRIMARY),

                      WithButtonState(AMOTION_EVENT_BUTTON_SECONDARY),

                      WithCoords(POINTER_X, POINTER_Y),

                      WithToolType(AMOTION_EVENT_TOOL_TYPE_FINGER)));

    args.pop_front();

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

                AllOf(WithMotionAction(AMOTION_EVENT_ACTION_BUTTON_RELEASE),

                      WithActionButton(AMOTION_EVENT_BUTTON_SECONDARY), WithButtonState(0),

                      WithCoords(POINTER_X, POINTER_Y),

                      WithToolType(AMOTION_EVENT_TOOL_TYPE_FINGER)));

    args.pop_front();

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

                AllOf(WithMotionAction(AMOTION_EVENT_ACTION_UP), WithButtonState(0),

                      WithCoords(POINTER_X, POINTER_Y),

                      WithToolType(AMOTION_EVENT_TOOL_TYPE_FINGER)));

}



TEST_F(GestureConverterTest, ResetDuringScroll) {

    InputDeviceContext deviceContext(*mDevice, EVENTHUB_ID);

    GestureConverter converter(*mReader->getContext(), deviceContext, DEVICE_ID);



    Gesture startGesture(kGestureScroll, ARBITRARY_GESTURE_TIME, ARBITRARY_GESTURE_TIME, 0, -10);

    (void)converter.handleGesture(ARBITRARY_TIME, READ_TIME, startGesture);



    std::list<NotifyArgs> args = converter.reset(ARBITRARY_TIME);

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

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

                AllOf(WithMotionAction(AMOTION_EVENT_ACTION_UP),

                      WithCoords(POINTER_X, POINTER_Y - 10),

                      WithGestureScrollDistance(0, 0, EPSILON),

                      WithMotionClassification(MotionClassification::TWO_FINGER_SWIPE),

                      WithToolType(AMOTION_EVENT_TOOL_TYPE_FINGER),

                      WithFlags(AMOTION_EVENT_FLAG_IS_GENERATED_GESTURE)));

}



TEST_F(GestureConverterTest, ResetDuringThreeFingerSwipe) {

    InputDeviceContext deviceContext(*mDevice, EVENTHUB_ID);

    GestureConverter converter(*mReader->getContext(), deviceContext, DEVICE_ID);



    Gesture startGesture(kGestureSwipe, ARBITRARY_GESTURE_TIME, ARBITRARY_GESTURE_TIME, /*dx=*/0,

                         /*dy=*/10);

    (void)converter.handleGesture(ARBITRARY_TIME, READ_TIME, startGesture);



    std::list<NotifyArgs> args = converter.reset(ARBITRARY_TIME);

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

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

                AllOf(WithMotionAction(AMOTION_EVENT_ACTION_POINTER_UP |

                                       2 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),

                      WithGestureOffset(0, 0, EPSILON),

                      WithMotionClassification(MotionClassification::MULTI_FINGER_SWIPE),

                      WithPointerCount(3u), WithToolType(AMOTION_EVENT_TOOL_TYPE_FINGER)));

    args.pop_front();

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

                AllOf(WithMotionAction(AMOTION_EVENT_ACTION_POINTER_UP |

                                       1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),

                      WithGestureOffset(0, 0, EPSILON),

                      WithMotionClassification(MotionClassification::MULTI_FINGER_SWIPE),

                      WithPointerCount(2u), WithToolType(AMOTION_EVENT_TOOL_TYPE_FINGER)));

    args.pop_front();

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

                AllOf(WithMotionAction(AMOTION_EVENT_ACTION_UP), WithGestureOffset(0, 0, EPSILON),

                      WithMotionClassification(MotionClassification::MULTI_FINGER_SWIPE),

                      WithPointerCount(1u), WithToolType(AMOTION_EVENT_TOOL_TYPE_FINGER)));

}



TEST_F(GestureConverterTest, ResetDuringPinch) {

    InputDeviceContext deviceContext(*mDevice, EVENTHUB_ID);

    GestureConverter converter(*mReader->getContext(), deviceContext, DEVICE_ID);



    Gesture startGesture(kGesturePinch, ARBITRARY_GESTURE_TIME, ARBITRARY_GESTURE_TIME, /*dz=*/1,

                         GESTURES_ZOOM_START);

    (void)converter.handleGesture(ARBITRARY_TIME, READ_TIME, startGesture);



    std::list<NotifyArgs> args = converter.reset(ARBITRARY_TIME);

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

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

                AllOf(WithMotionAction(AMOTION_EVENT_ACTION_POINTER_UP |

                                       1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),

                      WithMotionClassification(MotionClassification::PINCH),

                      WithGesturePinchScaleFactor(1.0f, EPSILON), WithPointerCount(2u),

                      WithToolType(AMOTION_EVENT_TOOL_TYPE_FINGER)));

    args.pop_front();

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

                AllOf(WithMotionAction(AMOTION_EVENT_ACTION_UP),

                      WithMotionClassification(MotionClassification::PINCH),

                      WithGesturePinchScaleFactor(1.0f, EPSILON), WithPointerCount(1u),

                      WithToolType(AMOTION_EVENT_TOOL_TYPE_FINGER)));

}



} // namespace android
 
} // namespace android