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

Commit 82357091 authored by chaviw's avatar chaviw
Browse files

Send raw coordinates to client but scale when getting relative 

The current code scales the coordinates before sending to the client.
This changes the coordinates so when the client requests raw
coordinates, they are actually getting the scaled ones. Instead, don't
scale the coordinates in InputDispatcher and instead send the scale
factors to the client. When the client requests raw coordinates, they
will get the unscaled ones. When they request relative coordinates, they
will get the coordinates with the scale and offset applied.

Fixes: 140786233
Test: atest libinput_tests
Change-Id: I99b9ce7236511f595a8780506bf5aea8c75ed577
parent 7a1ddcfc

libs/input/Input.cpp

+21 −21
Original line number Diff line number Diff line
@@ -321,17 +321,17 @@ void MotionEvent::addSample( 


float MotionEvent::getXCursorPosition() const {

    const float rawX = getRawXCursorPosition();

    return rawX + mXOffset;

    return rawX * mXScale + mXOffset;

}



float MotionEvent::getYCursorPosition() const {

    const float rawY = getRawYCursorPosition();

    return rawY + mYOffset;

    return rawY * mYScale + mYOffset;

}



void MotionEvent::setCursorPosition(float x, float y) {

    mRawXCursorPosition = x - mXOffset;

    mRawYCursorPosition = y - mYOffset;

    mRawXCursorPosition = (x - mXOffset) / mXScale;

    mRawYCursorPosition = (y - mYOffset) / mYScale;

}



const PointerCoords* MotionEvent::getRawPointerCoords(size_t pointerIndex) const {
@@ -346,9 +346,9 @@ float MotionEvent::getAxisValue(int32_t axis, size_t pointerIndex) const { 
    float value = getRawPointerCoords(pointerIndex)->getAxisValue(axis);

    switch (axis) {

    case AMOTION_EVENT_AXIS_X:

        return value + mXOffset;

        return value * mXScale + mXOffset;

    case AMOTION_EVENT_AXIS_Y:

        return value + mYOffset;

        return value * mYScale + mYOffset;

    }

    return value;

}
@@ -368,9 +368,9 @@ float MotionEvent::getHistoricalAxisValue(int32_t axis, size_t pointerIndex, 
    float value = getHistoricalRawPointerCoords(pointerIndex, historicalIndex)->getAxisValue(axis);

    switch (axis) {

    case AMOTION_EVENT_AXIS_X:

        return value + mXOffset;

        return value * mXScale + mXOffset;

    case AMOTION_EVENT_AXIS_Y:

        return value + mYOffset;

        return value * mYScale + mYOffset;

    }

    return value;

}
@@ -442,11 +442,11 @@ void MotionEvent::transform(const float matrix[9]) { 
    float oldXOffset = mXOffset;

    float oldYOffset = mYOffset;

    float newX, newY;

    float rawX = getRawX(0);

    float rawY = getRawY(0);

    transformPoint(matrix, rawX + oldXOffset, rawY + oldYOffset, &newX, &newY);

    mXOffset = newX - rawX;

    mYOffset = newY - rawY;

    float scaledRawX = getRawX(0) * mXScale;

    float scaledRawY = getRawY(0) * mYScale;

    transformPoint(matrix, scaledRawX + oldXOffset, scaledRawY + oldYOffset, &newX, &newY);

    mXOffset = newX - scaledRawX;

    mYOffset = newY - scaledRawY;



    // Determine how the origin is transformed by the matrix so that we

    // can transform orientation vectors.
@@ -455,22 +455,22 @@ void MotionEvent::transform(const float matrix[9]) { 


    // Apply the transformation to cursor position.

    if (isValidCursorPosition(mRawXCursorPosition, mRawYCursorPosition)) {

        float x = mRawXCursorPosition + oldXOffset;

        float y = mRawYCursorPosition + oldYOffset;

        float x = mRawXCursorPosition * mXScale + oldXOffset;

        float y = mRawYCursorPosition * mYScale + oldYOffset;

        transformPoint(matrix, x, y, &x, &y);

        mRawXCursorPosition = x - mXOffset;

        mRawYCursorPosition = y - mYOffset;

        mRawXCursorPosition = (x - mXOffset) / mXScale;

        mRawYCursorPosition = (y - mYOffset) / mYScale;

    }



    // Apply the transformation to all samples.

    size_t numSamples = mSamplePointerCoords.size();

    for (size_t i = 0; i < numSamples; i++) {

        PointerCoords& c = mSamplePointerCoords.editItemAt(i);

        float x = c.getAxisValue(AMOTION_EVENT_AXIS_X) + oldXOffset;

        float y = c.getAxisValue(AMOTION_EVENT_AXIS_Y) + oldYOffset;

        float x = c.getAxisValue(AMOTION_EVENT_AXIS_X) * mXScale + oldXOffset;

        float y = c.getAxisValue(AMOTION_EVENT_AXIS_Y) * mYScale + oldYOffset;

        transformPoint(matrix, x, y, &x, &y);

        c.setAxisValue(AMOTION_EVENT_AXIS_X, x - mXOffset);

        c.setAxisValue(AMOTION_EVENT_AXIS_Y, y - mYOffset);

        c.setAxisValue(AMOTION_EVENT_AXIS_X, (x - mXOffset) / mXScale);

        c.setAxisValue(AMOTION_EVENT_AXIS_Y, (y - mYOffset) / mYScale);



        float orientation = c.getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION);

        c.setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION,

libs/input/tests/InputEvent_test.cpp

+15 −15
Original line number Diff line number Diff line
@@ -375,19 +375,19 @@ void MotionEventTest::assertEqualsEventWithHistory(const MotionEvent* event) { 
    ASSERT_EQ(211, event->getRawY(0));

    ASSERT_EQ(221, event->getRawY(1));



    ASSERT_EQ(X_OFFSET + 10, event->getHistoricalX(0, 0));

    ASSERT_EQ(X_OFFSET + 20, event->getHistoricalX(1, 0));

    ASSERT_EQ(X_OFFSET + 110, event->getHistoricalX(0, 1));

    ASSERT_EQ(X_OFFSET + 120, event->getHistoricalX(1, 1));

    ASSERT_EQ(X_OFFSET + 210, event->getX(0));

    ASSERT_EQ(X_OFFSET + 220, event->getX(1));



    ASSERT_EQ(Y_OFFSET + 11, event->getHistoricalY(0, 0));

    ASSERT_EQ(Y_OFFSET + 21, event->getHistoricalY(1, 0));

    ASSERT_EQ(Y_OFFSET + 111, event->getHistoricalY(0, 1));

    ASSERT_EQ(Y_OFFSET + 121, event->getHistoricalY(1, 1));

    ASSERT_EQ(Y_OFFSET + 211, event->getY(0));

    ASSERT_EQ(Y_OFFSET + 221, event->getY(1));

    ASSERT_EQ(X_OFFSET + 10 * X_SCALE, event->getHistoricalX(0, 0));

    ASSERT_EQ(X_OFFSET + 20 * X_SCALE, event->getHistoricalX(1, 0));

    ASSERT_EQ(X_OFFSET + 110 * X_SCALE, event->getHistoricalX(0, 1));

    ASSERT_EQ(X_OFFSET + 120 * X_SCALE, event->getHistoricalX(1, 1));

    ASSERT_EQ(X_OFFSET + 210 * X_SCALE, event->getX(0));

    ASSERT_EQ(X_OFFSET + 220 * X_SCALE, event->getX(1));



    ASSERT_EQ(Y_OFFSET + 11 * Y_SCALE, event->getHistoricalY(0, 0));

    ASSERT_EQ(Y_OFFSET + 21 * Y_SCALE, event->getHistoricalY(1, 0));

    ASSERT_EQ(Y_OFFSET + 111 * Y_SCALE, event->getHistoricalY(0, 1));

    ASSERT_EQ(Y_OFFSET + 121 * Y_SCALE, event->getHistoricalY(1, 1));

    ASSERT_EQ(Y_OFFSET + 211 * Y_SCALE, event->getY(0));

    ASSERT_EQ(Y_OFFSET + 221 * Y_SCALE, event->getY(1));



    ASSERT_EQ(12, event->getHistoricalPressure(0, 0));

    ASSERT_EQ(22, event->getHistoricalPressure(1, 0));
@@ -513,8 +513,8 @@ TEST_F(MotionEventTest, Scale) { 


    ASSERT_EQ(210 * 2, event.getRawX(0));

    ASSERT_EQ(211 * 2, event.getRawY(0));

    ASSERT_EQ((X_OFFSET + 210) * 2, event.getX(0));

    ASSERT_EQ((Y_OFFSET + 211) * 2, event.getY(0));

    ASSERT_EQ((X_OFFSET + 210 * X_SCALE) * 2, event.getX(0));

    ASSERT_EQ((Y_OFFSET + 211 * Y_SCALE) * 2, event.getY(0));

    ASSERT_EQ(212, event.getPressure(0));

    ASSERT_EQ(213, event.getSize(0));

    ASSERT_EQ(214 * 2, event.getTouchMajor(0));

libs/input/tests/InputPublisherAndConsumer_test.cpp

+6 −6
Original line number Diff line number Diff line
@@ -221,8 +221,8 @@ void InputPublisherAndConsumerTest::PublishAndConsumeMotionEvent() { 
    EXPECT_EQ(yPrecision, motionEvent->getYPrecision());

    EXPECT_EQ(xCursorPosition, motionEvent->getRawXCursorPosition());

    EXPECT_EQ(yCursorPosition, motionEvent->getRawYCursorPosition());

    EXPECT_EQ(xCursorPosition + xOffset, motionEvent->getXCursorPosition());

    EXPECT_EQ(yCursorPosition + yOffset, motionEvent->getYCursorPosition());

    EXPECT_EQ(xCursorPosition * xScale + xOffset, motionEvent->getXCursorPosition());

    EXPECT_EQ(yCursorPosition * yScale + yOffset, motionEvent->getYCursorPosition());

    EXPECT_EQ(downTime, motionEvent->getDownTime());

    EXPECT_EQ(eventTime, motionEvent->getEventTime());

    EXPECT_EQ(pointerCount, motionEvent->getPointerCount());
@@ -237,9 +237,9 @@ void InputPublisherAndConsumerTest::PublishAndConsumeMotionEvent() { 
                motionEvent->getRawX(i));

        EXPECT_EQ(pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_Y),

                motionEvent->getRawY(i));

        EXPECT_EQ(pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_X) + xOffset,

        EXPECT_EQ(pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_X) * xScale + xOffset,

                  motionEvent->getX(i));

        EXPECT_EQ(pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_Y) + yOffset,

        EXPECT_EQ(pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_Y) * yScale + yOffset,

                  motionEvent->getY(i));

        EXPECT_EQ(pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE),

                motionEvent->getPressure(i));

services/inputflinger/dispatcher/InputDispatcher.cpp

+15 −15
Original line number Diff line number Diff line
@@ -2424,26 +2424,28 @@ void InputDispatcher::startDispatchCycleLocked(nsecs_t currentTime, 
                PointerCoords scaledCoords[MAX_POINTERS];

                const PointerCoords* usingCoords = motionEntry->pointerCoords;



                // Set the X and Y offset depending on the input source.

                float xOffset, yOffset;

                // Set the X and Y offset and X and Y scale depending on the input source.

                float xOffset = 0.0f, yOffset = 0.0f;

                float xScale = 1.0f, yScale = 1.0f;

                if ((motionEntry->source & AINPUT_SOURCE_CLASS_POINTER) &&

                    !(dispatchEntry->targetFlags & InputTarget::FLAG_ZERO_COORDS)) {

                    float globalScaleFactor = dispatchEntry->globalScaleFactor;

                    float wxs = dispatchEntry->windowXScale;

                    float wys = dispatchEntry->windowYScale;

                    xOffset = dispatchEntry->xOffset * wxs;

                    yOffset = dispatchEntry->yOffset * wys;

                    if (wxs != 1.0f || wys != 1.0f || globalScaleFactor != 1.0f) {

                    xScale = dispatchEntry->windowXScale;

                    yScale = dispatchEntry->windowYScale;

                    xOffset = dispatchEntry->xOffset * xScale;

                    yOffset = dispatchEntry->yOffset * yScale;

                    if (globalScaleFactor != 1.0f) {

                        for (uint32_t i = 0; i < motionEntry->pointerCount; i++) {

                            scaledCoords[i] = motionEntry->pointerCoords[i];

                            scaledCoords[i].scale(globalScaleFactor, wxs, wys);

                            // Don't apply window scale here since we don't want scale to affect raw

                            // coordinates. The scale will be sent back to the client and applied

                            // later when requesting relative coordinates.

                            scaledCoords[i].scale(globalScaleFactor, 1 /* windowXScale */,

                                                  1 /* windowYScale */);

                        }

                        usingCoords = scaledCoords;

                    }

                } else {

                    xOffset = 0.0f;

                    yOffset = 0.0f;



                    // We don't want the dispatch target to know.

                    if (dispatchEntry->targetFlags & InputTarget::FLAG_ZERO_COORDS) {

                        for (uint32_t i = 0; i < motionEntry->pointerCount; i++) {
@@ -2462,10 +2464,8 @@ void InputDispatcher::startDispatchCycleLocked(nsecs_t currentTime, 
                                                     dispatchEntry->resolvedFlags,

                                                     motionEntry->edgeFlags, motionEntry->metaState,

                                                     motionEntry->buttonState,

                                                     motionEntry->classification,

                                                     dispatchEntry->windowXScale,

                                                     dispatchEntry->windowYScale, xOffset, yOffset,

                                                     motionEntry->xPrecision,

                                                     motionEntry->classification, xScale, yScale,

                                                     xOffset, yOffset, motionEntry->xPrecision,

                                                     motionEntry->yPrecision,

                                                     motionEntry->xCursorPosition,

                                                     motionEntry->yCursorPosition,