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

Commit 379ea42d authored by Harry Cutts's avatar Harry Cutts
Browse files

GestureConverter: send HOVER_ENTER and _EXIT events 

Previously these were being put in by InputDispatcher automatically, but
ideally it wouldn't have to — an input mapper should produce a
consistent event stream in the first place.

Bug: 317183325
Test: atest inputflinger_tests
Test: with log.tag.InputDispatcherInboundEvent sysprop set to DEBUG,
      manually check events logged to InputDispatcher logcat tag
Change-Id: Ia74c4865da62520c8f8b7484def8b39c3eee820e
parent f71138d4

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

+79 −24
Original line number Diff line number Diff line
@@ -81,6 +81,7 @@ std::string GestureConverter::dump() const { 
    out << StringPrintf("Button state: 0x%08x\n", mButtonState);

    out << "Down time: " << mDownTime << "\n";

    out << "Current classification: " << ftl::enum_string(mCurrentClassification) << "\n";

    out << "Is hovering: " << mIsHovering << "\n";

    out << "Enable Tap Timestamp: " << mWhenToEnableTapToClick << "\n";

    return out.str();

}
@@ -89,7 +90,7 @@ std::list<NotifyArgs> GestureConverter::reset(nsecs_t when) { 
    std::list<NotifyArgs> out;

    switch (mCurrentClassification) {

        case MotionClassification::TWO_FINGER_SWIPE:

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

            out += endScroll(when, when);

            break;

        case MotionClassification::MULTI_FINGER_SWIPE:

            out += handleMultiFingerSwipeLift(when, when);
@@ -173,6 +174,8 @@ std::list<NotifyArgs> GestureConverter::handleMove(nsecs_t when, nsecs_t readTim 
                                                   const Gesture& gesture) {

    float deltaX = gesture.details.move.dx;

    float deltaY = gesture.details.move.dy;

    const auto [oldXCursorPosition, oldYCursorPosition] =

            mEnablePointerChoreographer ? FloatPoint{0, 0} : mPointerController->getPosition();

    if (ENABLE_TOUCHPAD_PALM_REJECTION_V2) {

        bool wasHoverCancelled = mIsHoverCancelled;

        // Gesture will be cancelled if it started before the user started typing and
@@ -184,6 +187,7 @@ std::list<NotifyArgs> GestureConverter::handleMove(nsecs_t when, nsecs_t readTim 
            // This is the first event of the cancelled gesture, we won't return because we need to

            // generate a HOVER_EXIT event

            mPointerController->fade(PointerControllerInterface::Transition::GRADUAL);

            return exitHover(when, readTime, oldXCursorPosition, oldYCursorPosition);

        } else if (mIsHoverCancelled) {

            return {};

        }
@@ -204,24 +208,27 @@ std::list<NotifyArgs> GestureConverter::handleMove(nsecs_t when, nsecs_t readTim 
        mPointerController->unfade(PointerControllerInterface::Transition::IMMEDIATE);

    }



    const auto [xCursorPosition, yCursorPosition] =

    std::list<NotifyArgs> out;

    const bool down = isPointerDown(mButtonState);

    if (!down) {

        out += enterHover(when, readTime, oldXCursorPosition, oldYCursorPosition);

    }

    const auto [newXCursorPosition, newYCursorPosition] =

            mEnablePointerChoreographer ? FloatPoint{0, 0} : 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_X, newXCursorPosition);

    coords.setAxisValue(AMOTION_EVENT_AXIS_Y, newYCursorPosition);

    coords.setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, deltaX);

    coords.setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, deltaY);

    const bool down = isPointerDown(mButtonState);

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



    const int32_t action = mIsHoverCancelled

            ? AMOTION_EVENT_ACTION_HOVER_EXIT

            : (down ? AMOTION_EVENT_ACTION_MOVE : AMOTION_EVENT_ACTION_HOVER_MOVE);

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

                           /* pointerCount= */ 1, mFingerProps.data(), &coords, xCursorPosition,

                           yCursorPosition)};

    const int32_t action = down ? AMOTION_EVENT_ACTION_MOVE : AMOTION_EVENT_ACTION_HOVER_MOVE;

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

                                 /*pointerCount=*/1, mFingerProps.data(), &coords,

                                 newXCursorPosition, newYCursorPosition));

    return out;

}



std::list<NotifyArgs> GestureConverter::handleButtonsChange(nsecs_t when, nsecs_t readTime,
@@ -276,6 +283,7 @@ std::list<NotifyArgs> GestureConverter::handleButtonsChange(nsecs_t when, nsecs_ 
    }

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

        mDownTime = when;

        out += exitHover(when, readTime, xCursorPosition, yCursorPosition);

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

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

                                     mFingerProps.data(), &coords, xCursorPosition,
@@ -304,11 +312,8 @@ std::list<NotifyArgs> GestureConverter::handleButtonsChange(nsecs_t when, nsecs_ 
        out.push_back(makeMotionArgs(when, readTime, AMOTION_EVENT_ACTION_UP, /* actionButton= */ 0,

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

                                     &coords, xCursorPosition, yCursorPosition));

        // Send a HOVER_MOVE to tell the application that the mouse is hovering again.

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

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

                                     mFingerProps.data(), &coords, xCursorPosition,

                                     yCursorPosition));

        mButtonState = newButtonState;

        out += enterHover(when, readTime, xCursorPosition, yCursorPosition);

    }

    mButtonState = newButtonState;

    return out;
@@ -338,13 +343,14 @@ std::list<NotifyArgs> GestureConverter::releaseAllButtons(nsecs_t when, nsecs_t 
                                         yCursorPosition));

        }

    }

    mButtonState = 0;

    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, /*pointerCount=*/1, mFingerProps.data(), &coords,

                                     xCursorPosition, yCursorPosition));

        out += enterHover(when, readTime, xCursorPosition, yCursorPosition);

    }

    mButtonState = 0;

    return out;

}
@@ -355,6 +361,8 @@ std::list<NotifyArgs> GestureConverter::handleScroll(nsecs_t when, nsecs_t readT 
    const auto [xCursorPosition, yCursorPosition] =

            mEnablePointerChoreographer ? FloatPoint{0, 0} : mPointerController->getPosition();

    if (mCurrentClassification != MotionClassification::TWO_FINGER_SWIPE) {

        out += exitHover(when, readTime, xCursorPosition, yCursorPosition);



        mCurrentClassification = MotionClassification::TWO_FINGER_SWIPE;

        coords.setAxisValue(AMOTION_EVENT_AXIS_X, xCursorPosition);

        coords.setAxisValue(AMOTION_EVENT_AXIS_Y, yCursorPosition);
@@ -395,7 +403,7 @@ std::list<NotifyArgs> GestureConverter::handleFling(nsecs_t when, nsecs_t readTi 
                // ensure consistency between touchscreen and touchpad flings), so we're just using

                // the "start fling" gestures as a marker for the end of a two-finger scroll

                // gesture.

                return {endScroll(when, readTime)};

                return endScroll(when, readTime);

            }

            break;

        case GESTURES_FLING_TAP_DOWN:
@@ -418,7 +426,8 @@ std::list<NotifyArgs> GestureConverter::handleFling(nsecs_t when, nsecs_t readTi 
    return {};

}



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

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

    std::list<NotifyArgs> out;

    const auto [xCursorPosition, yCursorPosition] =

            mEnablePointerChoreographer ? FloatPoint{0, 0} : mPointerController->getPosition();

    mFakeFingerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_GESTURE_SCROLL_X_DISTANCE, 0);
@@ -428,8 +437,10 @@ NotifyMotionArgs GestureConverter::endScroll(nsecs_t when, nsecs_t readTime) { 
                           mButtonState, /* pointerCount= */ 1, mFingerProps.data(),

                           mFakeFingerCoords.data(), xCursorPosition, yCursorPosition);

    args.flags |= AMOTION_EVENT_FLAG_IS_GENERATED_GESTURE;

    out.push_back(args);

    mCurrentClassification = MotionClassification::NONE;

    return args;

    out += enterHover(when, readTime, xCursorPosition, yCursorPosition);

    return out;

}



[[nodiscard]] std::list<NotifyArgs> GestureConverter::handleMultiFingerSwipe(nsecs_t when,
@@ -445,7 +456,11 @@ NotifyMotionArgs GestureConverter::endScroll(nsecs_t when, nsecs_t readTime) { 
        // three and then put a fourth finger down), the gesture library will treat it as two

        // separate swipes with an appropriate lift event between them, so we don't have to worry

        // about the finger count changing mid-swipe.



        out += exitHover(when, readTime, xCursorPosition, yCursorPosition);



        mCurrentClassification = MotionClassification::MULTI_FINGER_SWIPE;



        mSwipeFingerCount = fingerCount;



        constexpr float FAKE_FINGER_SPACING = 100;
@@ -521,6 +536,7 @@ NotifyMotionArgs GestureConverter::endScroll(nsecs_t when, nsecs_t readTime) { 
                                 yCursorPosition));

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

    mCurrentClassification = MotionClassification::NONE;

    out += enterHover(when, readTime, xCursorPosition, yCursorPosition);

    mSwipeFingerCount = 0;

    return out;

}
@@ -539,6 +555,10 @@ NotifyMotionArgs GestureConverter::endScroll(nsecs_t when, nsecs_t readTime) { 
        LOG_ALWAYS_FATAL_IF(gesture.details.pinch.zoom_state != GESTURES_ZOOM_START,

                            "First pinch gesture does not have the START zoom state (%d instead).",

                            gesture.details.pinch.zoom_state);

        std::list<NotifyArgs> out;



        out += exitHover(when, readTime, xCursorPosition, yCursorPosition);



        mCurrentClassification = MotionClassification::PINCH;

        mPinchFingerSeparation = INITIAL_PINCH_SEPARATION_PX;

        mFakeFingerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_GESTURE_PINCH_SCALE_FACTOR, 1.0);
@@ -551,7 +571,6 @@ NotifyMotionArgs GestureConverter::endScroll(nsecs_t when, nsecs_t readTime) { 
        mFakeFingerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_Y, yCursorPosition);

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

        mDownTime = when;

        std::list<NotifyArgs> out;

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

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

                                     mFingerProps.data(), mFakeFingerCoords.data(), xCursorPosition,
@@ -598,11 +617,47 @@ std::list<NotifyArgs> GestureConverter::endPinch(nsecs_t when, nsecs_t readTime) 
    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);

    mCurrentClassification = MotionClassification::NONE;

    out += enterHover(when, readTime, xCursorPosition, yCursorPosition);

    return out;

}



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

                                                   float xCursorPosition, float yCursorPosition) {

    if (!mIsHovering) {

        mIsHovering = true;

        return {makeHoverEvent(when, readTime, AMOTION_EVENT_ACTION_HOVER_ENTER, xCursorPosition,

                               yCursorPosition)};

    } else {

        return {};

    }

}



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

                                                  float xCursorPosition, float yCursorPosition) {

    if (mIsHovering) {

        mIsHovering = false;

        return {makeHoverEvent(when, readTime, AMOTION_EVENT_ACTION_HOVER_EXIT, xCursorPosition,

                               yCursorPosition)};

    } else {

        return {};

    }

}



NotifyMotionArgs GestureConverter::makeHoverEvent(nsecs_t when, nsecs_t readTime, int32_t action,

                                                  float xCursorPosition, float yCursorPosition) {

    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);

    return makeMotionArgs(when, readTime, action, /*actionButton=*/0, mButtonState,

                          /*pointerCount=*/1, mFingerProps.data(), &coords, xCursorPosition,

                          yCursorPosition);

}



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

                                                  int32_t actionButton, int32_t buttonState,

                                                  uint32_t pointerCount,

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

+12 −1
Original line number Diff line number Diff line
@@ -75,7 +75,7 @@ private: 
    [[nodiscard]] std::list<NotifyArgs> handleFling(nsecs_t when, nsecs_t readTime,

                                                    nsecs_t gestureStartTime,

                                                    const Gesture& gesture);

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

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



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

                                                               uint32_t fingerCount, float dx,
@@ -85,6 +85,14 @@ private: 
                                                    const Gesture& gesture);

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



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

                                                   float xCursorPosition, float yCursorPosition);

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

                                                  float xCursorPosition, float yCursorPosition);



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

                                    float xCursorPosition, float yCursorPosition);



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

                                    int32_t actionButton, int32_t buttonState,

                                    uint32_t pointerCount,
@@ -111,6 +119,9 @@ private: 
    // button values (AMOTION_EVENT_BUTTON_...).

    uint32_t mButtonState = 0;

    nsecs_t mDownTime = 0;

    // Whether we are currently in a hover state (i.e. a HOVER_ENTER event has been sent without a

    // matching HOVER_EXIT).

    bool mIsHovering = false;



    MotionClassification mCurrentClassification = MotionClassification::NONE;

    // Only used when mCurrentClassification is MULTI_FINGER_SWIPE.

services/inputflinger/tests/GestureConverter_test.cpp

+348 −154

File changed.

Preview size limit exceeded, changes collapsed.

services/inputflinger/tests/TouchpadInputMapper_test.cpp

+10 −4
Original line number Diff line number Diff line
@@ -37,6 +37,8 @@ constexpr auto ACTION_UP = AMOTION_EVENT_ACTION_UP; 
constexpr auto BUTTON_PRESS = AMOTION_EVENT_ACTION_BUTTON_PRESS;

constexpr auto BUTTON_RELEASE = AMOTION_EVENT_ACTION_BUTTON_RELEASE;

constexpr auto HOVER_MOVE = AMOTION_EVENT_ACTION_HOVER_MOVE;

constexpr auto HOVER_ENTER = AMOTION_EVENT_ACTION_HOVER_ENTER;

constexpr auto HOVER_EXIT = AMOTION_EVENT_ACTION_HOVER_EXIT;

constexpr int32_t DISPLAY_ID = 0;

constexpr int32_t DISPLAY_WIDTH = 480;

constexpr int32_t DISPLAY_HEIGHT = 800;
@@ -151,12 +153,14 @@ TEST_F(TouchpadInputMapperTest, HoverAndLeftButtonPress) { 
    setScanCodeState(KeyState::UP, {BTN_LEFT});

    args += process(EV_SYN, SYN_REPORT, 0);

    ASSERT_THAT(args,

                ElementsAre(VariantWith<NotifyMotionArgs>(WithMotionAction(HOVER_MOVE)),

                ElementsAre(VariantWith<NotifyMotionArgs>(WithMotionAction(HOVER_ENTER)),

                            VariantWith<NotifyMotionArgs>(WithMotionAction(HOVER_MOVE)),

                            VariantWith<NotifyMotionArgs>(WithMotionAction(HOVER_EXIT)),

                            VariantWith<NotifyMotionArgs>(WithMotionAction(ACTION_DOWN)),

                            VariantWith<NotifyMotionArgs>(WithMotionAction(BUTTON_PRESS)),

                            VariantWith<NotifyMotionArgs>(WithMotionAction(BUTTON_RELEASE)),

                            VariantWith<NotifyMotionArgs>(WithMotionAction(ACTION_UP)),

                            VariantWith<NotifyMotionArgs>(WithMotionAction(HOVER_MOVE))));

                            VariantWith<NotifyMotionArgs>(WithMotionAction(HOVER_ENTER))));



    // Liftoff

    args.clear();
@@ -218,12 +222,14 @@ TEST_F(TouchpadInputMapperTestWithChoreographer, HoverAndLeftButtonPress) { 
    setScanCodeState(KeyState::UP, {BTN_LEFT});

    args += process(EV_SYN, SYN_REPORT, 0);

    ASSERT_THAT(args,

                ElementsAre(VariantWith<NotifyMotionArgs>(WithMotionAction(HOVER_MOVE)),

                ElementsAre(VariantWith<NotifyMotionArgs>(WithMotionAction(HOVER_ENTER)),

                            VariantWith<NotifyMotionArgs>(WithMotionAction(HOVER_MOVE)),

                            VariantWith<NotifyMotionArgs>(WithMotionAction(HOVER_EXIT)),

                            VariantWith<NotifyMotionArgs>(WithMotionAction(ACTION_DOWN)),

                            VariantWith<NotifyMotionArgs>(WithMotionAction(BUTTON_PRESS)),

                            VariantWith<NotifyMotionArgs>(WithMotionAction(BUTTON_RELEASE)),

                            VariantWith<NotifyMotionArgs>(WithMotionAction(ACTION_UP)),

                            VariantWith<NotifyMotionArgs>(WithMotionAction(HOVER_MOVE))));

                            VariantWith<NotifyMotionArgs>(WithMotionAction(HOVER_ENTER))));



    // Liftoff

    args.clear();