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

Commit c294fddf authored by Chavi Weingarten's avatar Chavi Weingarten Committed by Android (Google) Code Review
Browse files

Merge "Send raw coordinates to client but scale when getting relative"

parents b13d54b0 82357091

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,