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

Commit 7e1ee565 authored by Prabir Pradhan's avatar Prabir Pradhan
Browse files

Move Joystick and Touchpad event transformation logic to MotionEvent 

We would like to have all source and axis based transformations
calculated in the same place, which will be in the MotionEvent class.
This has the added benefit that MotionEvents created by developers
through MotionEvent.obtain() in Java will behave like motion events
generated from input devices in terms of how they're affected by
transformations.

Since axes from joysticks and touchpads should never be transfomred,
we previously solved this by using identity matrices for them in
InputDispatcher. Now, we move that logic to MotionEvent when applying
the transform.

Bug: 179274888
Test: atest libinput_test
Test: atest inputflinger_tests
Change-Id: Ic02466e01f2ba3131aca73bd10933ff81cb38cc9
parent a1273194

include/input/Input.h

+4 −1
Original line number Diff line number Diff line
@@ -801,8 +801,11 @@ public: 


    static std::string actionToString(int32_t action);



    // MotionEvent will transform various axes in different ways, based on the source. For

    // example, the x and y axes will not have any offsets/translations applied if it comes from a

    // relative mouse device (since SOURCE_RELATIVE_MOUSE is a non-pointer source). These methods

    // are used to apply these transformations for different axes.

    static vec2 calculateTransformedXY(uint32_t source, const ui::Transform&, const vec2& xy);



    static float calculateTransformedAxisValue(int32_t axis, uint32_t source, const ui::Transform&,

                                               const PointerCoords&);

libs/input/Input.cpp

+30 −6
Original line number Diff line number Diff line
@@ -66,11 +66,21 @@ vec2 transformWithoutTranslation(const ui::Transform& transform, const vec2& xy) 
    return transformedXy - transformedOrigin;

}



bool shouldDisregardTranslation(uint32_t source) {

bool isFromSource(uint32_t source, uint32_t test) {

    return (source & test) == test;

}



bool shouldDisregardTransformation(uint32_t source) {

    // Do not apply any transformations to axes from joysticks or touchpads.

    return isFromSource(source, AINPUT_SOURCE_CLASS_JOYSTICK) ||

            isFromSource(source, AINPUT_SOURCE_CLASS_POSITION);

}



bool shouldDisregardOffset(uint32_t source) {

    // Pointer events are the only type of events that refer to absolute coordinates on the display,

    // so we should apply the entire window transform. For other types of events, we should make

    // sure to not apply the window translation/offset.

    return (source & AINPUT_SOURCE_CLASS_POINTER) == 0;

    return !isFromSource(source, AINPUT_SOURCE_CLASS_POINTER);

}



} // namespace
@@ -707,7 +717,7 @@ status_t MotionEvent::writeToParcel(Parcel* parcel) const { 
#endif



bool MotionEvent::isTouchEvent(uint32_t source, int32_t action) {

    if (source & AINPUT_SOURCE_CLASS_POINTER) {

    if (isFromSource(source, AINPUT_SOURCE_CLASS_POINTER)) {

        // Specifically excludes HOVER_MOVE and SCROLL.

        switch (action & AMOTION_EVENT_ACTION_MASK) {

        case AMOTION_EVENT_ACTION_DOWN:
@@ -764,17 +774,31 @@ std::string MotionEvent::actionToString(int32_t action) { 
    return android::base::StringPrintf("%" PRId32, action);

}



vec2 MotionEvent::calculateTransformedXY(uint32_t source, const ui::Transform& transform,

// Apply the given transformation to the point without checking whether the entire transform

// should be disregarded altogether for the provided source.

static inline vec2 calculateTransformedXYUnchecked(uint32_t source, const ui::Transform& transform,

                                                   const vec2& xy) {

    return shouldDisregardTranslation(source) ? transformWithoutTranslation(transform, xy)

    return shouldDisregardOffset(source) ? transformWithoutTranslation(transform, xy)

                                         : transform.transform(xy);

}



vec2 MotionEvent::calculateTransformedXY(uint32_t source, const ui::Transform& transform,

                                         const vec2& xy) {

    if (shouldDisregardTransformation(source)) {

        return xy;

    }

    return calculateTransformedXYUnchecked(source, transform, xy);

}



float MotionEvent::calculateTransformedAxisValue(int32_t axis, uint32_t source,

                                                 const ui::Transform& transform,

                                                 const PointerCoords& coords) {

    if (shouldDisregardTransformation(source)) {

        return coords.getAxisValue(axis);

    }



    if (axis == AMOTION_EVENT_AXIS_X || axis == AMOTION_EVENT_AXIS_Y) {

        const vec2 xy = calculateTransformedXY(source, transform, coords.getXYValue());

        const vec2 xy = calculateTransformedXYUnchecked(source, transform, coords.getXYValue());

        static_assert(AMOTION_EVENT_AXIS_X == 0 && AMOTION_EVENT_AXIS_Y == 1);

        return xy[axis];

    }

libs/input/tests/InputEvent_test.cpp

+43 −14
Original line number Diff line number Diff line
@@ -647,9 +647,8 @@ TEST_F(MotionEventTest, Transform) { 
    ASSERT_NEAR(originalRawY, event.getRawY(0), 0.001);

}



MotionEvent createTouchDownEvent(float x, float y, float dx, float dy,

                                 const ui::Transform& transform,

                                 const ui::Transform& rawTransform) {

MotionEvent createMotionEvent(int32_t source, uint32_t action, float x, float y, float dx, float dy,

                              const ui::Transform& transform, const ui::Transform& rawTransform) {

    std::vector<PointerProperties> pointerProperties;

    pointerProperties.push_back(PointerProperties{/* id */ 0, AMOTION_EVENT_TOOL_TYPE_FINGER});

    std::vector<PointerCoords> pointerCoords;
@@ -660,8 +659,8 @@ MotionEvent createTouchDownEvent(float x, float y, float dx, float dy, 
    pointerCoords.back().setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, dy);

    nsecs_t eventTime = systemTime(SYSTEM_TIME_MONOTONIC);

    MotionEvent event;

    event.initialize(InputEvent::nextId(), /* deviceId */ 1, AINPUT_SOURCE_TOUCHSCREEN,

                     /* displayId */ 0, INVALID_HMAC, AMOTION_EVENT_ACTION_DOWN,

    event.initialize(InputEvent::nextId(), /* deviceId */ 1, source,

                     /* displayId */ 0, INVALID_HMAC, action,

                     /* actionButton */ 0, /* flags */ 0, /* edgeFlags */ 0, AMETA_NONE,

                     /* buttonState */ 0, MotionClassification::NONE, transform,

                     /* xPrecision */ 0, /* yPrecision */ 0, AMOTION_EVENT_INVALID_CURSOR_POSITION,
@@ -670,6 +669,13 @@ MotionEvent createTouchDownEvent(float x, float y, float dx, float dy, 
    return event;

}



MotionEvent createTouchDownEvent(float x, float y, float dx, float dy,

                                 const ui::Transform& transform,

                                 const ui::Transform& rawTransform) {

    return createMotionEvent(AINPUT_SOURCE_TOUCHSCREEN, AMOTION_EVENT_ACTION_DOWN, x, y, dx, dy,

                             transform, rawTransform);

}



TEST_F(MotionEventTest, ApplyTransform) {

    // Create a rotate-90 transform with an offset (like a window which isn't fullscreen).

    ui::Transform identity;
@@ -708,16 +714,39 @@ TEST_F(MotionEventTest, ApplyTransform) { 
                changedEvent.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, 0), 0.001);

}



TEST_F(MotionEventTest, JoystickAndTouchpadAreNotTransformed) {

    constexpr static std::array kNonTransformedSources = {std::pair(AINPUT_SOURCE_TOUCHPAD,

                                                                    AMOTION_EVENT_ACTION_DOWN),

                                                          std::pair(AINPUT_SOURCE_JOYSTICK,

                                                                    AMOTION_EVENT_ACTION_MOVE)};

    // Create a rotate-90 transform with an offset (like a window which isn't fullscreen).

    ui::Transform transform(ui::Transform::ROT_90, 800, 400);

    transform.set(transform.tx() + 20, transform.ty() + 40);



    for (const auto& [source, action] : kNonTransformedSources) {

        const MotionEvent event =

                createMotionEvent(source, action, 60, 100, 0, 0, transform, transform);



        // These events should not be transformed in any way.

        ASSERT_EQ(60, event.getX(0));

        ASSERT_EQ(100, event.getY(0));

        ASSERT_EQ(event.getRawX(0), event.getX(0));

        ASSERT_EQ(event.getRawY(0), event.getY(0));

    }

}



TEST_F(MotionEventTest, NonPointerSourcesAreNotTranslated) {

    constexpr static auto NON_POINTER_SOURCES = {AINPUT_SOURCE_TRACKBALL,

                                                 AINPUT_SOURCE_MOUSE_RELATIVE,

                                                 AINPUT_SOURCE_JOYSTICK};

    for (uint32_t source : NON_POINTER_SOURCES) {

    constexpr static std::array kNonPointerSources = {std::pair(AINPUT_SOURCE_TRACKBALL,

                                                                AMOTION_EVENT_ACTION_DOWN),

                                                      std::pair(AINPUT_SOURCE_MOUSE_RELATIVE,

                                                                AMOTION_EVENT_ACTION_MOVE)};

    // Create a rotate-90 transform with an offset (like a window which isn't fullscreen).

    ui::Transform transform(ui::Transform::ROT_90, 800, 400);

    transform.set(transform.tx() + 20, transform.ty() + 40);

        MotionEvent event = createTouchDownEvent(60, 100, 42, 96, transform, transform);

        event.setSource(source);



    for (const auto& [source, action] : kNonPointerSources) {

        const MotionEvent event =

                createMotionEvent(source, action, 60, 100, 42, 96, transform, transform);



        // Since this event comes from a non-pointer source, it should include rotation but not

        // translation/offset.

services/inputflinger/dispatcher/InputDispatcher.cpp

+0 −12
Original line number Diff line number Diff line
@@ -342,18 +342,6 @@ bool isStaleEvent(nsecs_t currentTime, const EventEntry& entry) { 
std::unique_ptr<DispatchEntry> createDispatchEntry(const InputTarget& inputTarget,

                                                   std::shared_ptr<EventEntry> eventEntry,

                                                   int32_t inputTargetFlags) {

    if (eventEntry->type == EventEntry::Type::MOTION) {

        const MotionEntry& motionEntry = static_cast<const MotionEntry&>(*eventEntry);

        if ((motionEntry.source & AINPUT_SOURCE_CLASS_JOYSTICK) ||

            (motionEntry.source & AINPUT_SOURCE_CLASS_POSITION)) {

            const ui::Transform identityTransform;

            // Use identity transform for joystick and position-based (touchpad) events because they

            // don't depend on the window transform.

            return std::make_unique<DispatchEntry>(eventEntry, inputTargetFlags, identityTransform,

                                                   identityTransform, 1.0f /*globalScaleFactor*/);

        }

    }



    if (inputTarget.useDefaultPointerTransform()) {

        const ui::Transform& transform = inputTarget.getDefaultPointerTransform();

        return std::make_unique<DispatchEntry>(eventEntry, inputTargetFlags, transform,

services/inputflinger/tests/InputDispatcher_test.cpp

+0 −53
Original line number Diff line number Diff line
@@ -3012,59 +3012,6 @@ TEST_F(InputDispatcherTest, VerifyInputEvent_MotionEvent) { 
    EXPECT_EQ(motionArgs.buttonState, verifiedMotion.buttonState);

}



TEST_F(InputDispatcherTest, NonPointerMotionEvent_JoystickAndTouchpadNotTransformed) {

    std::shared_ptr<FakeApplicationHandle> application = std::make_shared<FakeApplicationHandle>();

    sp<FakeWindowHandle> window =

            new FakeWindowHandle(application, mDispatcher, "Test window", ADISPLAY_ID_DEFAULT);

    const std::string name = window->getName();



    // Window gets transformed by offset values.

    window->setWindowOffset(500.0f, 500.0f);



    mDispatcher->setFocusedApplication(ADISPLAY_ID_DEFAULT, application);

    window->setFocusable(true);



    mDispatcher->setInputWindows({{ADISPLAY_ID_DEFAULT, {window}}});



    // First, we set focused window so that focusedWindowHandle is not null.

    setFocusedWindow(window);



    // Second, we consume focus event if it is right or wrong according to onFocusChangedLocked.

    window->consumeFocusEvent(true);



    constexpr const std::array nonTransformedSources = {std::pair(AINPUT_SOURCE_TOUCHPAD,

                                                                  AMOTION_EVENT_ACTION_DOWN),

                                                        std::pair(AINPUT_SOURCE_JOYSTICK,

                                                                  AMOTION_EVENT_ACTION_MOVE)};

    for (const auto& [source, action] : nonTransformedSources) {

        const NotifyMotionArgs motionArgs = generateMotionArgs(action, source, ADISPLAY_ID_DEFAULT);

        mDispatcher->notifyMotion(&motionArgs);



        MotionEvent* event = window->consumeMotion();

        ASSERT_NE(event, nullptr);



        const MotionEvent& motionEvent = *event;

        EXPECT_EQ(action, motionEvent.getAction());

        EXPECT_EQ(motionArgs.pointerCount, motionEvent.getPointerCount());



        float expectedX = motionArgs.pointerCoords[0].getX();

        float expectedY = motionArgs.pointerCoords[0].getY();



        // Ensure the axis values from the final motion event are not transformed.

        EXPECT_EQ(expectedX, motionEvent.getX(0))

                << "expected " << expectedX << " for x coord of " << name.c_str() << ", got "

                << motionEvent.getX(0);

        EXPECT_EQ(expectedY, motionEvent.getY(0))

                << "expected " << expectedY << " for y coord of " << name.c_str() << ", got "

                << motionEvent.getY(0);

        // Ensure the raw and transformed axis values for the motion event are the same.

        EXPECT_EQ(motionEvent.getRawX(0), motionEvent.getX(0))

                << "expected raw and transformed X-axis values to be equal";

        EXPECT_EQ(motionEvent.getRawY(0), motionEvent.getY(0))

                << "expected raw and transformed Y-axis values to be equal";

    }

}



/**

 * Ensure that separate calls to sign the same data are generating the same key.

 * We avoid asserting against INVALID_HMAC. Since the key is random, there is a non-zero chance