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

Commit 4b8d36c0 authored by Prabir Pradhan's avatar Prabir Pradhan
Browse files

MotionEvent: Consolidate functions to transform PointerCoords 

Remove PointerCoords::transform(), which is a duplicate of
MotionEvent::calculateTranformedCoords().

Bug: 342349872
Test: atest inputflinger_tests libinput_tests
Change-Id: I7610a0475a16e9964817f63efa67b291cb7aaf0a
parent 9a53b55a

include/input/Input.h

+2 −2
Original line number Diff line number Diff line
@@ -478,8 +478,6 @@ struct PointerCoords { 
    // axes, however the window scaling will not.

    void scale(float globalScale, float windowXScale, float windowYScale);



    void transform(const ui::Transform& transform, int32_t motionEventFlags);



    inline float getX() const {

        return getAxisValue(AMOTION_EVENT_AXIS_X);

    }
@@ -948,6 +946,8 @@ public: 
    static vec2 calculateTransformedXY(uint32_t source, const ui::Transform&, const vec2& xy);

    static float calculateTransformedAxisValue(int32_t axis, uint32_t source, int32_t flags,

                                               const ui::Transform&, const PointerCoords&);

    static void calculateTransformedCoordsInPlace(PointerCoords& coords, uint32_t source,

                                                  int32_t flags, const ui::Transform&);

    static PointerCoords calculateTransformedCoords(uint32_t source, int32_t flags,

                                                    const ui::Transform&, const PointerCoords&);

    // The rounding precision for transformed motion events.

libs/input/Input.cpp

+18 −33
Original line number Diff line number Diff line
@@ -548,26 +548,6 @@ bool PointerCoords::operator==(const PointerCoords& other) const { 
    return true;

}



void PointerCoords::transform(const ui::Transform& transform, int32_t motionEventFlags) {

    const vec2 xy = transform.transform(getXYValue());

    setAxisValue(AMOTION_EVENT_AXIS_X, xy.x);

    setAxisValue(AMOTION_EVENT_AXIS_Y, xy.y);



    if (BitSet64::hasBit(bits, AMOTION_EVENT_AXIS_RELATIVE_X) ||

        BitSet64::hasBit(bits, AMOTION_EVENT_AXIS_RELATIVE_Y)) {

        const ui::Transform rotation(transform.getOrientation());

        const vec2 relativeXy = rotation.transform(getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X),

                                                   getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y));

        setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, relativeXy.x);

        setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, relativeXy.y);

    }



    if ((motionEventFlags & AMOTION_EVENT_PRIVATE_FLAG_SUPPORTS_ORIENTATION) != 0) {

        setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION,

                     transformOrientation(transform, *this, motionEventFlags));

    }

}



// --- MotionEvent ---



void MotionEvent::initialize(int32_t id, int32_t deviceId, uint32_t source,
@@ -804,8 +784,9 @@ void MotionEvent::applyTransform(const std::array<float, 9>& matrix) { 
    transform.set(matrix);



    // Apply the transformation to all samples.

    std::for_each(mSamplePointerCoords.begin(), mSamplePointerCoords.end(),

                  [&](PointerCoords& c) { c.transform(transform, mFlags); });

    std::for_each(mSamplePointerCoords.begin(), mSamplePointerCoords.end(), [&](PointerCoords& c) {

        calculateTransformedCoordsInPlace(c, mSource, mFlags, transform);

    });



    if (mRawXCursorPosition != AMOTION_EVENT_INVALID_CURSOR_POSITION &&

        mRawYCursorPosition != AMOTION_EVENT_INVALID_CURSOR_POSITION) {
@@ -1107,28 +1088,32 @@ float MotionEvent::calculateTransformedAxisValue(int32_t axis, uint32_t source, 


// Keep in sync with calculateTransformedAxisValue. This is an optimization of

// calculateTransformedAxisValue for all PointerCoords axes.

PointerCoords MotionEvent::calculateTransformedCoords(uint32_t source, int32_t flags,

                                                      const ui::Transform& transform,

                                                      const PointerCoords& coords) {

void MotionEvent::calculateTransformedCoordsInPlace(PointerCoords& coords, uint32_t source,

                                                    int32_t flags, const ui::Transform& transform) {

    if (shouldDisregardTransformation(source)) {

        return coords;

        return;

    }

    PointerCoords out = coords;



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

    out.setAxisValue(AMOTION_EVENT_AXIS_X, xy.x);

    out.setAxisValue(AMOTION_EVENT_AXIS_Y, xy.y);

    coords.setAxisValue(AMOTION_EVENT_AXIS_X, xy.x);

    coords.setAxisValue(AMOTION_EVENT_AXIS_Y, xy.y);



    const vec2 relativeXy =

            transformWithoutTranslation(transform,

                                        {coords.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X),

                                         coords.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y)});

    out.setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, relativeXy.x);

    out.setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, relativeXy.y);

    coords.setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, relativeXy.x);

    coords.setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, relativeXy.y);



    out.setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION,

    coords.setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION,

                        transformOrientation(transform, coords, flags));

}



PointerCoords MotionEvent::calculateTransformedCoords(uint32_t source, int32_t flags,

                                                      const ui::Transform& transform,

                                                      const PointerCoords& coords) {

    PointerCoords out = coords;

    calculateTransformedCoordsInPlace(out, source, flags, transform);

    return out;

}

services/inputflinger/dispatcher/InputDispatcher.cpp

+4 −2
Original line number Diff line number Diff line
@@ -444,10 +444,12 @@ std::unique_ptr<DispatchEntry> createDispatchEntry(const IdGenerator& idGenerato 
            newCoords.copyFrom(motionEntry.pointerCoords[i]);

            // First, apply the current pointer's transform to update the coordinates into

            // window space.

            newCoords.transform(currTransform, motionEntry.flags);

            MotionEvent::calculateTransformedCoordsInPlace(newCoords, motionEntry.source,

                                                           motionEntry.flags, currTransform);

            // Next, apply the inverse transform of the normalized coordinates so the

            // current coordinates are transformed into the normalized coordinate space.

            newCoords.transform(inverseTransform, motionEntry.flags);

            MotionEvent::calculateTransformedCoordsInPlace(newCoords, motionEntry.source,

                                                           motionEntry.flags, inverseTransform);

        }

    }