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

Commit 313c1122 authored by android-build-team Robot's avatar android-build-team Robot
Browse files

Snap for 6353066 from 5ea5df56 to rvc-release 

Change-Id: I6d048ab4d342bf73a1d7919d7ea1492387e7ba9d
parents e3c13cde 5ea5df56

libs/dumputils/dump_utils.cpp

+1 −0
Original line number Diff line number Diff line
@@ -73,6 +73,7 @@ static const char* hal_interfaces_to_dump[] { 
        "android.hardware.thermal@2.0::IThermal",

        "android.hardware.vr@1.0::IVr",

        "android.hardware.automotive.audiocontrol@1.0::IAudioControl",

        "android.hardware.automotive.audiocontrol@2.0::IAudioControl",

        "android.hardware.automotive.vehicle@2.0::IVehicle",

        "android.hardware.automotive.evs@1.0::IEvsCamera",

        "android.hardware.neuralnetworks@1.0::IDevice",

services/inputflinger/reader/mapper/TouchInputMapper.cpp

+57 −49
Original line number Diff line number Diff line
@@ -160,8 +160,8 @@ TouchInputMapper::TouchInputMapper(InputDeviceContext& deviceContext) 
      : InputMapper(deviceContext),

        mSource(0),

        mDeviceMode(DEVICE_MODE_DISABLED),

        mSurfaceWidth(-1),

        mSurfaceHeight(-1),

        mRawSurfaceWidth(-1),

        mRawSurfaceHeight(-1),

        mSurfaceLeft(0),

        mSurfaceTop(0),

        mPhysicalWidth(-1),
@@ -680,7 +680,7 @@ void TouchInputMapper::configureSurface(nsecs_t when, bool* outResetNeeded) { 
                    naturalLogicalHeight = mViewport.logicalRight - mViewport.logicalLeft;

                    naturalPhysicalWidth = mViewport.physicalBottom - mViewport.physicalTop;

                    naturalPhysicalHeight = mViewport.physicalRight - mViewport.physicalLeft;

                    naturalPhysicalLeft = mViewport.deviceHeight - naturalPhysicalWidth;

                    naturalPhysicalLeft = mViewport.deviceHeight - mViewport.physicalBottom;

                    naturalPhysicalTop = mViewport.physicalLeft;

                    naturalDeviceWidth = mViewport.deviceHeight;

                    naturalDeviceHeight = mViewport.deviceWidth;
@@ -701,7 +701,7 @@ void TouchInputMapper::configureSurface(nsecs_t when, bool* outResetNeeded) { 
                    naturalPhysicalWidth = mViewport.physicalBottom - mViewport.physicalTop;

                    naturalPhysicalHeight = mViewport.physicalRight - mViewport.physicalLeft;

                    naturalPhysicalLeft = mViewport.physicalTop;

                    naturalPhysicalTop = mViewport.deviceWidth - naturalPhysicalHeight;

                    naturalPhysicalTop = mViewport.deviceWidth - mViewport.physicalRight;

                    naturalDeviceWidth = mViewport.deviceHeight;

                    naturalDeviceHeight = mViewport.deviceWidth;

                    break;
@@ -729,10 +729,12 @@ void TouchInputMapper::configureSurface(nsecs_t when, bool* outResetNeeded) { 
            mPhysicalLeft = naturalPhysicalLeft;

            mPhysicalTop = naturalPhysicalTop;



            mSurfaceWidth = naturalLogicalWidth * naturalDeviceWidth / naturalPhysicalWidth;

            mSurfaceHeight = naturalLogicalHeight * naturalDeviceHeight / naturalPhysicalHeight;

            mRawSurfaceWidth = naturalLogicalWidth * naturalDeviceWidth / naturalPhysicalWidth;

            mRawSurfaceHeight = naturalLogicalHeight * naturalDeviceHeight / naturalPhysicalHeight;

            mSurfaceLeft = naturalPhysicalLeft * naturalLogicalWidth / naturalPhysicalWidth;

            mSurfaceTop = naturalPhysicalTop * naturalLogicalHeight / naturalPhysicalHeight;

            mSurfaceRight = mSurfaceLeft + naturalLogicalWidth;

            mSurfaceBottom = mSurfaceTop + naturalLogicalHeight;



            mSurfaceOrientation =

                    mParameters.orientationAware ? mViewport.orientation : DISPLAY_ORIENTATION_0;
@@ -742,8 +744,8 @@ void TouchInputMapper::configureSurface(nsecs_t when, bool* outResetNeeded) { 
            mPhysicalLeft = 0;

            mPhysicalTop = 0;



            mSurfaceWidth = rawWidth;

            mSurfaceHeight = rawHeight;

            mRawSurfaceWidth = rawWidth;

            mRawSurfaceHeight = rawHeight;

            mSurfaceLeft = 0;

            mSurfaceTop = 0;

            mSurfaceOrientation = DISPLAY_ORIENTATION_0;
@@ -769,12 +771,12 @@ void TouchInputMapper::configureSurface(nsecs_t when, bool* outResetNeeded) { 
    if (viewportChanged || deviceModeChanged) {

        ALOGI("Device reconfigured: id=%d, name='%s', size %dx%d, orientation %d, mode %d, "

              "display id %d",

              getDeviceId(), getDeviceName().c_str(), mSurfaceWidth, mSurfaceHeight,

              getDeviceId(), getDeviceName().c_str(), mRawSurfaceWidth, mRawSurfaceHeight,

              mSurfaceOrientation, mDeviceMode, mViewport.displayId);



        // Configure X and Y factors.

        mXScale = float(mSurfaceWidth) / rawWidth;

        mYScale = float(mSurfaceHeight) / rawHeight;

        mXScale = float(mRawSurfaceWidth) / rawWidth;

        mYScale = float(mRawSurfaceHeight) / rawHeight;

        mXTranslate = -mSurfaceLeft;

        mYTranslate = -mSurfaceTop;

        mXPrecision = 1.0f / mXScale;
@@ -793,7 +795,7 @@ void TouchInputMapper::configureSurface(nsecs_t when, bool* outResetNeeded) { 
        mGeometricScale = avg(mXScale, mYScale);



        // Size of diagonal axis.

        float diagonalSize = hypotf(mSurfaceWidth, mSurfaceHeight);

        float diagonalSize = hypotf(mRawSurfaceWidth, mRawSurfaceHeight);



        // Size factors.

        if (mCalibration.sizeCalibration != Calibration::SIZE_CALIBRATION_NONE) {
@@ -956,13 +958,13 @@ void TouchInputMapper::configureSurface(nsecs_t when, bool* outResetNeeded) { 
                mOrientedYPrecision = mXPrecision;



                mOrientedRanges.x.min = mYTranslate;

                mOrientedRanges.x.max = mSurfaceHeight + mYTranslate - 1;

                mOrientedRanges.x.max = mRawSurfaceHeight + mYTranslate - 1;

                mOrientedRanges.x.flat = 0;

                mOrientedRanges.x.fuzz = 0;

                mOrientedRanges.x.resolution = mRawPointerAxes.y.resolution * mYScale;



                mOrientedRanges.y.min = mXTranslate;

                mOrientedRanges.y.max = mSurfaceWidth + mXTranslate - 1;

                mOrientedRanges.y.max = mRawSurfaceWidth + mXTranslate - 1;

                mOrientedRanges.y.flat = 0;

                mOrientedRanges.y.fuzz = 0;

                mOrientedRanges.y.resolution = mRawPointerAxes.x.resolution * mXScale;
@@ -973,13 +975,13 @@ void TouchInputMapper::configureSurface(nsecs_t when, bool* outResetNeeded) { 
                mOrientedYPrecision = mYPrecision;



                mOrientedRanges.x.min = mXTranslate;

                mOrientedRanges.x.max = mSurfaceWidth + mXTranslate - 1;

                mOrientedRanges.x.max = mRawSurfaceWidth + mXTranslate - 1;

                mOrientedRanges.x.flat = 0;

                mOrientedRanges.x.fuzz = 0;

                mOrientedRanges.x.resolution = mRawPointerAxes.x.resolution * mXScale;



                mOrientedRanges.y.min = mYTranslate;

                mOrientedRanges.y.max = mSurfaceHeight + mYTranslate - 1;

                mOrientedRanges.y.max = mRawSurfaceHeight + mYTranslate - 1;

                mOrientedRanges.y.flat = 0;

                mOrientedRanges.y.fuzz = 0;

                mOrientedRanges.y.resolution = mRawPointerAxes.y.resolution * mYScale;
@@ -992,7 +994,7 @@ void TouchInputMapper::configureSurface(nsecs_t when, bool* outResetNeeded) { 
        if (mDeviceMode == DEVICE_MODE_POINTER) {

            // Compute pointer gesture detection parameters.

            float rawDiagonal = hypotf(rawWidth, rawHeight);

            float displayDiagonal = hypotf(mSurfaceWidth, mSurfaceHeight);

            float displayDiagonal = hypotf(mRawSurfaceWidth, mRawSurfaceHeight);



            // Scale movements such that one whole swipe of the touch pad covers a

            // given area relative to the diagonal size of the display when no acceleration
@@ -1027,10 +1029,12 @@ void TouchInputMapper::configureSurface(nsecs_t when, bool* outResetNeeded) { 


void TouchInputMapper::dumpSurface(std::string& dump) {

    dump += StringPrintf(INDENT3 "%s\n", mViewport.toString().c_str());

    dump += StringPrintf(INDENT3 "SurfaceWidth: %dpx\n", mSurfaceWidth);

    dump += StringPrintf(INDENT3 "SurfaceHeight: %dpx\n", mSurfaceHeight);

    dump += StringPrintf(INDENT3 "RawSurfaceWidth: %dpx\n", mRawSurfaceWidth);

    dump += StringPrintf(INDENT3 "RawSurfaceHeight: %dpx\n", mRawSurfaceHeight);

    dump += StringPrintf(INDENT3 "SurfaceLeft: %d\n", mSurfaceLeft);

    dump += StringPrintf(INDENT3 "SurfaceTop: %d\n", mSurfaceTop);

    dump += StringPrintf(INDENT3 "SurfaceRight: %d\n", mSurfaceRight);

    dump += StringPrintf(INDENT3 "SurfaceBottom: %d\n", mSurfaceBottom);

    dump += StringPrintf(INDENT3 "PhysicalWidth: %dpx\n", mPhysicalWidth);

    dump += StringPrintf(INDENT3 "PhysicalHeight: %dpx\n", mPhysicalHeight);

    dump += StringPrintf(INDENT3 "PhysicalLeft: %d\n", mPhysicalLeft);
@@ -1074,16 +1078,16 @@ void TouchInputMapper::configureVirtualKeys() { 
        int32_t halfHeight = virtualKeyDefinition.height / 2;



        virtualKey.hitLeft =

                (virtualKeyDefinition.centerX - halfWidth) * touchScreenWidth / mSurfaceWidth +

                (virtualKeyDefinition.centerX - halfWidth) * touchScreenWidth / mRawSurfaceWidth +

                touchScreenLeft;

        virtualKey.hitRight =

                (virtualKeyDefinition.centerX + halfWidth) * touchScreenWidth / mSurfaceWidth +

                (virtualKeyDefinition.centerX + halfWidth) * touchScreenWidth / mRawSurfaceWidth +

                touchScreenLeft;

        virtualKey.hitTop =

                (virtualKeyDefinition.centerY - halfHeight) * touchScreenHeight / mSurfaceHeight +

        virtualKey.hitTop = (virtualKeyDefinition.centerY - halfHeight) * touchScreenHeight /

                        mRawSurfaceHeight +

                touchScreenTop;

        virtualKey.hitBottom =

                (virtualKeyDefinition.centerY + halfHeight) * touchScreenHeight / mSurfaceHeight +

        virtualKey.hitBottom = (virtualKeyDefinition.centerY + halfHeight) * touchScreenHeight /

                        mRawSurfaceHeight +

                touchScreenTop;

        mVirtualKeys.push_back(virtualKey);

    }
@@ -2188,13 +2192,10 @@ void TouchInputMapper::cookPointerData() { 
        rotateAndScale(xTransformed, yTransformed);



        // Adjust X, Y, and coverage coords for surface orientation.

        float x, y;

        float left, top, right, bottom;



        switch (mSurfaceOrientation) {

            case DISPLAY_ORIENTATION_90:

                x = yTransformed + mYTranslate;

                y = xTransformed + mXTranslate;

                left = float(rawTop - mRawPointerAxes.y.minValue) * mYScale + mYTranslate;

                right = float(rawBottom - mRawPointerAxes.y.minValue) * mYScale + mYTranslate;

                bottom = float(mRawPointerAxes.x.maxValue - rawLeft) * mXScale + mXTranslate;
@@ -2207,8 +2208,6 @@ void TouchInputMapper::cookPointerData() { 
                }

                break;

            case DISPLAY_ORIENTATION_180:

                x = xTransformed + mXTranslate;

                y = yTransformed + mYTranslate;

                left = float(mRawPointerAxes.x.maxValue - rawRight) * mXScale;

                right = float(mRawPointerAxes.x.maxValue - rawLeft) * mXScale;

                bottom = float(mRawPointerAxes.y.maxValue - rawTop) * mYScale + mYTranslate;
@@ -2221,8 +2220,6 @@ void TouchInputMapper::cookPointerData() { 
                }

                break;

            case DISPLAY_ORIENTATION_270:

                x = yTransformed + mYTranslate;

                y = xTransformed + mXTranslate;

                left = float(mRawPointerAxes.y.maxValue - rawBottom) * mYScale;

                right = float(mRawPointerAxes.y.maxValue - rawTop) * mYScale;

                bottom = float(rawRight - mRawPointerAxes.x.minValue) * mXScale + mXTranslate;
@@ -2235,8 +2232,6 @@ void TouchInputMapper::cookPointerData() { 
                }

                break;

            default:

                x = xTransformed + mXTranslate;

                y = yTransformed + mYTranslate;

                left = float(rawLeft - mRawPointerAxes.x.minValue) * mXScale + mXTranslate;

                right = float(rawRight - mRawPointerAxes.x.minValue) * mXScale + mXTranslate;

                bottom = float(rawBottom - mRawPointerAxes.y.minValue) * mYScale + mYTranslate;
@@ -2247,8 +2242,8 @@ void TouchInputMapper::cookPointerData() { 
        // Write output coords.

        PointerCoords& out = mCurrentCookedState.cookedPointerData.pointerCoords[i];

        out.clear();

        out.setAxisValue(AMOTION_EVENT_AXIS_X, x);

        out.setAxisValue(AMOTION_EVENT_AXIS_Y, y);

        out.setAxisValue(AMOTION_EVENT_AXIS_X, xTransformed);

        out.setAxisValue(AMOTION_EVENT_AXIS_Y, yTransformed);

        out.setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, pressure);

        out.setAxisValue(AMOTION_EVENT_AXIS_SIZE, size);

        out.setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, touchMajor);
@@ -3624,34 +3619,47 @@ void TouchInputMapper::cancelTouch(nsecs_t when) { 
    abortTouches(when, 0 /* policyFlags*/);

}



// Transform raw coordinate to surface coordinate

void TouchInputMapper::rotateAndScale(float& x, float& y) {

    // Scale to surface coordinate.

    const float xScaled = float(x - mRawPointerAxes.x.minValue) * mXScale;

    const float yScaled = float(y - mRawPointerAxes.y.minValue) * mYScale;



    // Rotate to surface coordinate.

    // 0 - no swap and reverse.

    // 90 - swap x/y and reverse y.

    // 180 - reverse x, y.

    // 270 - swap x/y and reverse x.

    switch (mSurfaceOrientation) {

        case DISPLAY_ORIENTATION_0:

            x = xScaled + mXTranslate;

            y = yScaled + mYTranslate;

            break;

        case DISPLAY_ORIENTATION_90:

            x = float(mRawPointerAxes.x.maxValue - x) * mXScale;

            y = float(y - mRawPointerAxes.y.minValue) * mYScale;

            y = mSurfaceRight - xScaled;

            x = yScaled + mYTranslate;

            break;

        case DISPLAY_ORIENTATION_180:

            x = float(mRawPointerAxes.x.maxValue - x) * mXScale;

            y = float(mRawPointerAxes.y.maxValue - y) * mYScale;

            x = mSurfaceRight - xScaled;

            y = mSurfaceBottom - yScaled;

            break;

        case DISPLAY_ORIENTATION_270:

            x = float(x - mRawPointerAxes.x.minValue) * mXScale;

            y = float(mRawPointerAxes.y.maxValue - y) * mYScale;

            y = xScaled + mXTranslate;

            x = mSurfaceBottom - yScaled;

            break;

        default:

            x = float(x - mRawPointerAxes.x.minValue) * mXScale;

            y = float(y - mRawPointerAxes.y.minValue) * mYScale;

            break;

            assert(false);

    }

}



bool TouchInputMapper::isPointInsideSurface(int32_t x, int32_t y) {

    float xTransformed = x, yTransformed = y;

    rotateAndScale(xTransformed, yTransformed);

    const float xScaled = (x - mRawPointerAxes.x.minValue) * mXScale;

    const float yScaled = (y - mRawPointerAxes.y.minValue) * mYScale;



    return x >= mRawPointerAxes.x.minValue && x <= mRawPointerAxes.x.maxValue &&

            xTransformed >= mSurfaceLeft && xTransformed <= mSurfaceLeft + mSurfaceWidth &&

            xScaled >= mSurfaceLeft && xScaled <= mSurfaceRight &&

            y >= mRawPointerAxes.y.minValue && y <= mRawPointerAxes.y.maxValue &&

            yTransformed >= mSurfaceTop && yTransformed <= mSurfaceTop + mSurfaceHeight;

            yScaled >= mSurfaceTop && yScaled <= mSurfaceBottom;

}



const TouchInputMapper::VirtualKey* TouchInputMapper::findVirtualKeyHit(int32_t x, int32_t y) {

services/inputflinger/reader/mapper/TouchInputMapper.h

+6 −2
Original line number Diff line number Diff line
@@ -407,12 +407,16 @@ private: 
    // The surface orientation, width and height set by configureSurface().

    // The width and height are derived from the viewport but are specified

    // in the natural orientation.

    // They could be used for calculating diagonal, scaling factors, and virtual keys.

    int32_t mRawSurfaceWidth;

    int32_t mRawSurfaceHeight;



    // The surface origin specifies how the surface coordinates should be translated

    // to align with the logical display coordinate space.

    int32_t mSurfaceWidth;

    int32_t mSurfaceHeight;

    int32_t mSurfaceLeft;

    int32_t mSurfaceTop;

    int32_t mSurfaceRight;

    int32_t mSurfaceBottom;



    // Similar to the surface coordinates, but in the raw display coordinate space rather than in

    // the logical coordinate space.

services/inputflinger/tests/InputReader_test.cpp

+126 −44
Original line number Diff line number Diff line
@@ -6990,51 +6990,7 @@ TEST_F(MultiTouchInputMapperTest, Configure_EnabledForAssociatedDisplay) { 
    ASSERT_EQ(SECONDARY_DISPLAY_ID, args.displayId);

}



/**

 * Test touch should not work if outside of surface.

 */

TEST_F(MultiTouchInputMapperTest, Viewports_SurfaceRange) {

    addConfigurationProperty("touch.deviceType", "touchScreen");

    prepareDisplay(DISPLAY_ORIENTATION_0);

    prepareAxes(POSITION);

    MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();



    // Touch on left-top area should work.

    int32_t rawX = DISPLAY_WIDTH / 2 - 1;

    int32_t rawY = DISPLAY_HEIGHT / 2 - 1;

    processPosition(mapper, rawX, rawY);

    processSync(mapper);



    NotifyMotionArgs args;

    ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));



    // Reset.

    mapper.reset(ARBITRARY_TIME);



    // Let logical display be different to physical display and rotate 90-degrees.

    std::optional<DisplayViewport> internalViewport =

            mFakePolicy->getDisplayViewportByType(ViewportType::VIEWPORT_INTERNAL);

    internalViewport->orientation = DISPLAY_ORIENTATION_90;

    internalViewport->logicalLeft = 0;

    internalViewport->logicalTop = 0;

    internalViewport->logicalRight = DISPLAY_HEIGHT;

    internalViewport->logicalBottom = DISPLAY_WIDTH / 2;



    internalViewport->physicalLeft = DISPLAY_HEIGHT;

    internalViewport->physicalTop = DISPLAY_WIDTH / 2;

    internalViewport->physicalRight = DISPLAY_HEIGHT;

    internalViewport->physicalBottom = DISPLAY_WIDTH;



    internalViewport->deviceWidth = DISPLAY_HEIGHT;

    internalViewport->deviceHeight = DISPLAY_WIDTH;

    mFakePolicy->updateViewport(internalViewport.value());

    configureDevice(InputReaderConfiguration::CHANGE_DISPLAY_INFO);



    // Display align to right-top after rotate 90-degrees, touch on left-top area should not work.

    processPosition(mapper, rawX, rawY);

    processSync(mapper);

    ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());

}



TEST_F(MultiTouchInputMapperTest, Process_ShouldHandleSingleTouch) {

    addConfigurationProperty("touch.deviceType", "touchScreen");
@@ -7161,4 +7117,130 @@ TEST_F(MultiTouchInputMapperTest_ExternalDevice, Viewports_Fallback) { 
    ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&motionArgs));

    ASSERT_EQ(SECONDARY_DISPLAY_ID, motionArgs.displayId);

}



/**

 * Test touch should not work if outside of surface.

 */

class MultiTouchInputMapperTest_SurfaceRange : public MultiTouchInputMapperTest {

protected:

    void halfDisplayToCenterHorizontal(int32_t orientation) {

        std::optional<DisplayViewport> internalViewport =

                mFakePolicy->getDisplayViewportByType(ViewportType::VIEWPORT_INTERNAL);



        // Half display to (width/4, 0, width * 3/4, height) to make display has offset.

        internalViewport->orientation = orientation;

        if (orientation == DISPLAY_ORIENTATION_90 || orientation == DISPLAY_ORIENTATION_270) {

            internalViewport->logicalLeft = 0;

            internalViewport->logicalTop = 0;

            internalViewport->logicalRight = DISPLAY_HEIGHT;

            internalViewport->logicalBottom = DISPLAY_WIDTH / 2;



            internalViewport->physicalLeft = 0;

            internalViewport->physicalTop = DISPLAY_WIDTH / 4;

            internalViewport->physicalRight = DISPLAY_HEIGHT;

            internalViewport->physicalBottom = DISPLAY_WIDTH * 3 / 4;



            internalViewport->deviceWidth = DISPLAY_HEIGHT;

            internalViewport->deviceHeight = DISPLAY_WIDTH;

        } else {

            internalViewport->logicalLeft = 0;

            internalViewport->logicalTop = 0;

            internalViewport->logicalRight = DISPLAY_WIDTH / 2;

            internalViewport->logicalBottom = DISPLAY_HEIGHT;



            internalViewport->physicalLeft = DISPLAY_WIDTH / 4;

            internalViewport->physicalTop = 0;

            internalViewport->physicalRight = DISPLAY_WIDTH * 3 / 4;

            internalViewport->physicalBottom = DISPLAY_HEIGHT;



            internalViewport->deviceWidth = DISPLAY_WIDTH;

            internalViewport->deviceHeight = DISPLAY_HEIGHT;

        }



        mFakePolicy->updateViewport(internalViewport.value());

        configureDevice(InputReaderConfiguration::CHANGE_DISPLAY_INFO);

    }



    void processPositionAndVerify(MultiTouchInputMapper& mapper, int32_t xInside, int32_t yInside,

                                  int32_t xOutside, int32_t yOutside, int32_t xExpected,

                                  int32_t yExpected) {

        // touch on outside area should not work.

        processPosition(mapper, toRawX(xOutside), toRawY(yOutside));

        processSync(mapper);

        ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());



        // touch on inside area should receive the event.

        NotifyMotionArgs args;

        processPosition(mapper, toRawX(xInside), toRawY(yInside));

        processSync(mapper);

        ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));

        ASSERT_NEAR(xExpected, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X), 1);

        ASSERT_NEAR(yExpected, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y), 1);



        // Reset.

        mapper.reset(ARBITRARY_TIME);

    }

};



TEST_F(MultiTouchInputMapperTest_SurfaceRange, Viewports_SurfaceRange) {

    addConfigurationProperty("touch.deviceType", "touchScreen");

    prepareDisplay(DISPLAY_ORIENTATION_0);

    prepareAxes(POSITION);

    MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();



    // Touch on center of normal display should work.

    const int32_t x = DISPLAY_WIDTH / 4;

    const int32_t y = DISPLAY_HEIGHT / 2;

    processPosition(mapper, toRawX(x), toRawY(y));

    processSync(mapper);

    NotifyMotionArgs args;

    ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasCalled(&args));

    ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0], x, y, 1.0f, 0.0f, 0.0f, 0.0f,

                                                0.0f, 0.0f, 0.0f, 0.0f));

    // Reset.

    mapper.reset(ARBITRARY_TIME);



    // Let physical display be different to device, and make surface and physical could be 1:1.

    halfDisplayToCenterHorizontal(DISPLAY_ORIENTATION_0);



    const int32_t xExpected = (x + 1) - (DISPLAY_WIDTH / 4);

    const int32_t yExpected = y;

    processPositionAndVerify(mapper, x - 1, y, x + 1, y, xExpected, yExpected);

}



TEST_F(MultiTouchInputMapperTest_SurfaceRange, Viewports_SurfaceRange_90) {

    addConfigurationProperty("touch.deviceType", "touchScreen");

    prepareDisplay(DISPLAY_ORIENTATION_0);

    prepareAxes(POSITION);

    MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();



    // Half display to (width/4, 0, width * 3/4, height) and rotate 90-degrees.

    halfDisplayToCenterHorizontal(DISPLAY_ORIENTATION_90);



    const int32_t x = DISPLAY_WIDTH / 4;

    const int32_t y = DISPLAY_HEIGHT / 2;



    // expect x/y = swap x/y then reverse y.

    const int32_t xExpected = y;

    const int32_t yExpected = (DISPLAY_WIDTH * 3 / 4) - (x + 1);

    processPositionAndVerify(mapper, x - 1, y, x + 1, y, xExpected, yExpected);

}



TEST_F(MultiTouchInputMapperTest_SurfaceRange, Viewports_SurfaceRange_270) {

    addConfigurationProperty("touch.deviceType", "touchScreen");

    prepareDisplay(DISPLAY_ORIENTATION_0);

    prepareAxes(POSITION);

    MultiTouchInputMapper& mapper = addMapperAndConfigure<MultiTouchInputMapper>();



    // Half display to (width/4, 0, width * 3/4, height) and rotate 270-degrees.

    halfDisplayToCenterHorizontal(DISPLAY_ORIENTATION_270);



    const int32_t x = DISPLAY_WIDTH / 4;

    const int32_t y = DISPLAY_HEIGHT / 2;



    // expect x/y = swap x/y then reverse x.

    constexpr int32_t xExpected = DISPLAY_HEIGHT - y;

    constexpr int32_t yExpected = (x + 1) - DISPLAY_WIDTH / 4;

    processPositionAndVerify(mapper, x - 1, y, x + 1, y, xExpected, yExpected);

}

} // namespace android

services/surfaceflinger/BufferLayer.cpp

+7 −2
Original line number Diff line number Diff line
@@ -272,7 +272,7 @@ bool BufferLayer::isHdrY410() const { 
    // pixel format is HDR Y410 masquerading as RGBA_1010102

    return (mBufferInfo.mDataspace == ui::Dataspace::BT2020_ITU_PQ &&

            mBufferInfo.mApi == NATIVE_WINDOW_API_MEDIA &&

            mBufferInfo.mBuffer->getPixelFormat() == HAL_PIXEL_FORMAT_RGBA_1010102);

            mBufferInfo.mPixelFormat == HAL_PIXEL_FORMAT_RGBA_1010102);

}



sp<compositionengine::LayerFE> BufferLayer::getCompositionEngineLayerFE() const {
@@ -374,6 +374,12 @@ bool BufferLayer::onPostComposition(sp<const DisplayDevice> displayDevice, 
    return true;

}



void BufferLayer::gatherBufferInfo() {

    mBufferInfo.mPixelFormat =

            !mBufferInfo.mBuffer ? PIXEL_FORMAT_NONE : mBufferInfo.mBuffer->format;

    mBufferInfo.mFrameLatencyNeeded = true;

}



bool BufferLayer::latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime,

                              nsecs_t expectedPresentTime) {

    ATRACE_CALL();
@@ -434,7 +440,6 @@ bool BufferLayer::latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime, 
    gatherBufferInfo();



    mRefreshPending = true;

    mBufferInfo.mFrameLatencyNeeded = true;

    if (oldBufferInfo.mBuffer == nullptr) {

        // the first time we receive a buffer, we need to trigger a

        // geometry invalidation.