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

Commit fdff5cde authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Android (Google) Code Review
Browse files

Merge changes I111361f7,Ic4979b91 

* changes:
  Reset the touch state when the active viewport is disabled
  Fix issues with InputMapper tests
parents 0064fad2 c0bdeefd

services/inputflinger/reader/mapper/TouchInputMapper.cpp

+17 −25
Original line number Diff line number Diff line
@@ -46,6 +46,8 @@ static constexpr nsecs_t STYLUS_DATA_LATENCY = ms2ns(10); 
static const float MIN_FREEFORM_GESTURE_WIDTH_IN_MILLIMETER = 30;

// --- Static Definitions ---



static const DisplayViewport kUninitializedViewport;



template <typename T>

inline static void swap(T& a, T& b) {

    T temp = a;
@@ -392,10 +394,10 @@ void TouchInputMapper::configure(nsecs_t when, const InputReaderConfiguration* c 
    }



    if (changes && resetNeeded) {

        // If device was reset, cancel touch event and update touch spot state.

        cancelTouch(mCurrentRawState.when, mCurrentRawState.readTime);

        mCurrentCookedState.clear();

        updateTouchSpots();

        // If the device needs to be reset, cancel any ongoing gestures and reset the state.

        cancelTouch(when, when);

        reset(when);



        // Send reset, unless this is the first time the device has been configured,

        // in which case the reader will call reset itself after all mappers are ready.

        NotifyDeviceResetArgs args(getContext()->getNextId(), when, getDeviceId());
@@ -886,7 +888,7 @@ void TouchInputMapper::initializeOrientedRanges() { 
}



void TouchInputMapper::configureInputDevice(nsecs_t when, bool* outResetNeeded) {

    DeviceMode oldDeviceMode = mDeviceMode;

    const DeviceMode oldDeviceMode = mDeviceMode;



    resolveExternalStylusPresence();
@@ -915,31 +917,24 @@ void TouchInputMapper::configureInputDevice(nsecs_t when, bool* outResetNeeded) 
        mDeviceMode = DeviceMode::UNSCALED;

    }



    // Ensure we have valid X and Y axes.

    const std::optional<DisplayViewport> newViewportOpt = findViewport();



    // Ensure the device is valid and can be used.

    if (!mRawPointerAxes.x.valid || !mRawPointerAxes.y.valid) {

        ALOGW("Touch device '%s' did not report support for X or Y axis!  "

              "The device will be inoperable.",

              getDeviceName().c_str());

        mDeviceMode = DeviceMode::DISABLED;

        return;

    }



    // Get associated display dimensions.

    std::optional<DisplayViewport> newViewport = findViewport();

    if (!newViewport) {

    } else if (!newViewportOpt) {

        ALOGI("Touch device '%s' could not query the properties of its associated "

              "display.  The device will be inoperable until the display size "

              "becomes available.",

              getDeviceName().c_str());

        mDeviceMode = DeviceMode::DISABLED;

        return;

    }



    if (!newViewport->isActive) {

    } else if (!newViewportOpt->isActive) {

        ALOGI("Disabling %s (device %i) because the associated viewport is not active",

              getDeviceName().c_str(), getDeviceId());

        mDeviceMode = DeviceMode::DISABLED;

        return;

    }



    // Raw width and height in the natural orientation.
@@ -951,12 +946,13 @@ void TouchInputMapper::configureInputDevice(nsecs_t when, bool* outResetNeeded) 
    const float rawMeanResolution =

            (rawXResolution > 0 && rawYResolution > 0) ? (rawXResolution + rawYResolution) / 2 : 0;



    const bool viewportChanged = mViewport != *newViewport;

    const DisplayViewport& newViewport = newViewportOpt.value_or(kUninitializedViewport);

    const bool viewportChanged = mViewport != newViewport;

    bool skipViewportUpdate = false;

    if (viewportChanged) {

        const bool viewportOrientationChanged = mViewport.orientation != newViewport->orientation;

        const bool viewportDisplayIdChanged = mViewport.displayId != newViewport->displayId;

        mViewport = *newViewport;

        const bool viewportOrientationChanged = mViewport.orientation != newViewport.orientation;

        const bool viewportDisplayIdChanged = mViewport.displayId != newViewport.displayId;

        mViewport = newViewport;



        if (mDeviceMode == DeviceMode::DIRECT || mDeviceMode == DeviceMode::POINTER) {

            // Convert rotated viewport to the natural orientation.
@@ -1118,10 +1114,6 @@ void TouchInputMapper::configureInputDevice(nsecs_t when, bool* outResetNeeded) 
            mPointerGestureMaxSwipeWidth =

                    std::max(mConfig.pointerGestureSwipeMaxWidthRatio * rawDiagonal,

                             minFreeformGestureWidth);



            // Abort current pointer usages because the state has changed.

            const nsecs_t readTime = when; // synthetic event

            abortPointerUsage(when, readTime, 0 /*policyFlags*/);

        }



        // Inform the dispatcher about the changes.

services/inputflinger/tests/InputReader_test.cpp

+71 −10
Original line number Diff line number Diff line
@@ -2945,6 +2945,8 @@ protected: 
        mReader = std::make_unique<InstrumentedInputReader>(mFakeEventHub, mFakePolicy,

                                                            *mFakeListener);

        mDevice = newDevice(DEVICE_ID, DEVICE_NAME, DEVICE_LOCATION, EVENTHUB_ID, classes);

        // Consume the device reset notification generated when adding a new device.

        mFakeListener->assertNotifyDeviceResetWasCalled();

    }



    void SetUp() override {
@@ -2969,6 +2971,8 @@ protected: 
            mReader->loopOnce();

        }

        mDevice->configure(ARBITRARY_TIME, mFakePolicy->getReaderConfiguration(), changes);

        // Loop the reader to flush the input listener queue.

        mReader->loopOnce();

    }



    std::shared_ptr<InputDevice> newDevice(int32_t deviceId, const std::string& name,
@@ -2992,6 +2996,8 @@ protected: 
        configureDevice(0);

        mDevice->reset(ARBITRARY_TIME);

        mapper.reset(ARBITRARY_TIME);

        // Loop the reader to flush the input listener queue.

        mReader->loopOnce();

        return mapper;

    }
@@ -3017,6 +3023,7 @@ protected: 
        event.code = code;

        event.value = value;

        mapper.process(&event);

        // Loop the reader to flush the input listener queue.

        mReader->loopOnce();

    }
@@ -4913,7 +4920,6 @@ TEST_F(CursorInputMapperTest, Process_PointerCapture) { 
    ASSERT_TRUE(mReader->getContext()->getGeneration() != generation);



    ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled(&resetArgs));

    ASSERT_EQ(ARBITRARY_TIME, resetArgs.eventTime);

    ASSERT_EQ(DEVICE_ID, resetArgs.deviceId);



    process(mapper, ARBITRARY_TIME, READ_TIME, EV_REL, REL_X, 10);
@@ -6724,6 +6730,61 @@ TEST_F(SingleTouchInputMapperTest, 
    ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled());

}



TEST_F(SingleTouchInputMapperTest,

       Process_WhenViewportActiveStatusChanged_TouchIsCanceledAndDeviceIsReset) {

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

    prepareDisplay(DISPLAY_ORIENTATION_0);

    prepareButtons();

    prepareAxes(POSITION);

    SingleTouchInputMapper& mapper = addMapperAndConfigure<SingleTouchInputMapper>();

    ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled());

    NotifyMotionArgs motionArgs;



    // Start a new gesture.

    processDown(mapper, 100, 200);

    processSync(mapper);

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

    ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);



    // Make the viewport inactive. This will put the device in disabled mode.

    auto viewport = mFakePolicy->getDisplayViewportByType(ViewportType::INTERNAL);

    viewport->isActive = false;

    mFakePolicy->updateViewport(*viewport);

    configureDevice(InputReaderConfiguration::CHANGE_DISPLAY_INFO);



    // We should receive a cancel event for the ongoing gesture.

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

    ASSERT_EQ(AMOTION_EVENT_ACTION_CANCEL, motionArgs.action);

    // Then we should be notified that the device was reset.

    ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled());



    // No events are generated while the viewport is inactive.

    processMove(mapper, 101, 201);

    processSync(mapper);

    processDown(mapper, 102, 202);

    processSync(mapper);

    ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());



    // Make the viewport active again. The device should resume processing events.

    viewport->isActive = true;

    mFakePolicy->updateViewport(*viewport);

    configureDevice(InputReaderConfiguration::CHANGE_DISPLAY_INFO);



    // The device is reset because it changes back to direct mode, without generating any events.

    ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasCalled());

    ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());



    // Start a new gesture.

    processDown(mapper, 100, 200);

    processSync(mapper);

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

    ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);



    // No more events.

    ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());

    ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyDeviceResetWasNotCalled());

}



// --- TouchDisplayProjectionTest ---



class TouchDisplayProjectionTest : public SingleTouchInputMapperTest {
@@ -8581,27 +8642,27 @@ TEST_F(MultiTouchInputMapperTest, Process_DeactivateViewport_AbortTouches) { 
    ASSERT_TRUE(mFakePolicy->updateViewport(displayViewport));

    configureDevice(InputReaderConfiguration::CHANGE_DISPLAY_INFO);



    // Finger move

    // The ongoing touch should be canceled immediately

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

    EXPECT_EQ(AMOTION_EVENT_ACTION_CANCEL, motionArgs.action);



    // Finger move is ignored

    x += 10, y += 10;

    processPosition(mapper, x, y);

    processSync(mapper);



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

    EXPECT_EQ(AMOTION_EVENT_ACTION_CANCEL, motionArgs.action);

    ASSERT_NO_FATAL_FAILURE(mFakeListener->assertNotifyMotionWasNotCalled());



    // Reactivate display viewport

    displayViewport.isActive = true;

    ASSERT_TRUE(mFakePolicy->updateViewport(displayViewport));

    configureDevice(InputReaderConfiguration::CHANGE_DISPLAY_INFO);



    // Finger move again

    // Finger move again starts new gesture

    x += 10, y += 10;

    processPosition(mapper, x, y);

    processSync(mapper);



    // Gesture is aborted, so events after display is activated won't be dispatched until there is

    // no pointer on the touch device.

    mFakeListener->assertNotifyMotionWasNotCalled();

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

    EXPECT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);

}



TEST_F(MultiTouchInputMapperTest, Process_Pointer_ShowTouches) {