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

Commit 29b38f3b authored by Arpit Singh's avatar Arpit Singh Committed by Android (Google) Code Review
Browse files

Merge changes from topic "InputMapper-refactor-256009910" into udc-dev 

* changes:
  InputMapper refactor: CursorInputMapper
  InputMapper refactor: Modify InputMapper constructor for configuration
parents 1549d661 7c6712df

services/inputflinger/reader/InputDevice.cpp

+95 −84
Original line number Diff line number Diff line
@@ -146,98 +146,23 @@ void InputDevice::dump(std::string& dump, const std::string& eventHubDevStr) { 
    }

}



void InputDevice::addEventHubDevice(int32_t eventHubId, bool populateMappers) {

void InputDevice::addEmptyEventHubDevice(int32_t eventHubId) {

    if (mDevices.find(eventHubId) != mDevices.end()) {

        return;

    }

    std::unique_ptr<InputDeviceContext> contextPtr(new InputDeviceContext(*this, eventHubId));

    ftl::Flags<InputDeviceClass> classes = contextPtr->getDeviceClasses();

    std::vector<std::unique_ptr<InputMapper>> mappers;



    // Check if we should skip population

    if (!populateMappers) {

    mDevices.insert({eventHubId, std::make_pair(std::move(contextPtr), std::move(mappers))});

        return;

    }



    // Switch-like devices.

    if (classes.test(InputDeviceClass::SWITCH)) {

        mappers.push_back(std::make_unique<SwitchInputMapper>(*contextPtr));

    }



    // Scroll wheel-like devices.

    if (classes.test(InputDeviceClass::ROTARY_ENCODER)) {

        mappers.push_back(std::make_unique<RotaryEncoderInputMapper>(*contextPtr));

    }



    // Vibrator-like devices.

    if (classes.test(InputDeviceClass::VIBRATOR)) {

        mappers.push_back(std::make_unique<VibratorInputMapper>(*contextPtr));

    }



    // Battery-like devices or light-containing devices.

    // PeripheralController will be created with associated EventHub device.

    if (classes.test(InputDeviceClass::BATTERY) || classes.test(InputDeviceClass::LIGHT)) {

        mController = std::make_unique<PeripheralController>(*contextPtr);

    }



    // Keyboard-like devices.

    uint32_t keyboardSource = 0;

    int32_t keyboardType = AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC;

    if (classes.test(InputDeviceClass::KEYBOARD)) {

        keyboardSource |= AINPUT_SOURCE_KEYBOARD;

    }

    if (classes.test(InputDeviceClass::ALPHAKEY)) {

        keyboardType = AINPUT_KEYBOARD_TYPE_ALPHABETIC;

    }

    if (classes.test(InputDeviceClass::DPAD)) {

        keyboardSource |= AINPUT_SOURCE_DPAD;

    }

    if (classes.test(InputDeviceClass::GAMEPAD)) {

        keyboardSource |= AINPUT_SOURCE_GAMEPAD;

}



    if (keyboardSource != 0) {

        mappers.push_back(

                std::make_unique<KeyboardInputMapper>(*contextPtr, keyboardSource, keyboardType));

    }



    // Cursor-like devices.

    if (classes.test(InputDeviceClass::CURSOR)) {

        mappers.push_back(std::make_unique<CursorInputMapper>(*contextPtr));

    }



    // Touchscreens and touchpad devices.

    static const bool ENABLE_TOUCHPAD_GESTURES_LIBRARY =

            sysprop::InputProperties::enable_touchpad_gestures_library().value_or(true);

    // TODO(b/272518665): Fix the new touchpad stack for Sony DualShock 4 (5c4, 9cc) touchpads, or

    // at least load this setting from the IDC file.

    const InputDeviceIdentifier identifier = contextPtr->getDeviceIdentifier();

    const bool isSonyDualShock4Touchpad = identifier.vendor == 0x054c &&

            (identifier.product == 0x05c4 || identifier.product == 0x09cc);

    if (ENABLE_TOUCHPAD_GESTURES_LIBRARY && classes.test(InputDeviceClass::TOUCHPAD) &&

        classes.test(InputDeviceClass::TOUCH_MT) && !isSonyDualShock4Touchpad) {

        mappers.push_back(std::make_unique<TouchpadInputMapper>(*contextPtr));

    } else if (classes.test(InputDeviceClass::TOUCH_MT)) {

        mappers.push_back(std::make_unique<MultiTouchInputMapper>(*contextPtr));

    } else if (classes.test(InputDeviceClass::TOUCH)) {

        mappers.push_back(std::make_unique<SingleTouchInputMapper>(*contextPtr));

    }



    // Joystick-like devices.

    if (classes.test(InputDeviceClass::JOYSTICK)) {

        mappers.push_back(std::make_unique<JoystickInputMapper>(*contextPtr));

    }



    // Motion sensor enabled devices.

    if (classes.test(InputDeviceClass::SENSOR)) {

        mappers.push_back(std::make_unique<SensorInputMapper>(*contextPtr));

    }



    // External stylus-like devices.

    if (classes.test(InputDeviceClass::EXTERNAL_STYLUS)) {

        mappers.push_back(std::make_unique<ExternalStylusInputMapper>(*contextPtr));

void InputDevice::addEventHubDevice(int32_t eventHubId,

                                    const InputReaderConfiguration& readerConfig) {

    if (mDevices.find(eventHubId) != mDevices.end()) {

        return;

    }

    std::unique_ptr<InputDeviceContext> contextPtr(new InputDeviceContext(*this, eventHubId));

    std::vector<std::unique_ptr<InputMapper>> mappers = createMappers(*contextPtr, readerConfig);



    // insert the context into the devices set

    mDevices.insert({eventHubId, std::make_pair(std::move(contextPtr), std::move(mappers))});
@@ -512,6 +437,92 @@ int32_t InputDevice::getState(uint32_t sourceMask, int32_t code, GetStateFunc ge 
    return result;

}



std::vector<std::unique_ptr<InputMapper>> InputDevice::createMappers(

        InputDeviceContext& contextPtr, const InputReaderConfiguration& readerConfig) {

    ftl::Flags<InputDeviceClass> classes = contextPtr.getDeviceClasses();

    std::vector<std::unique_ptr<InputMapper>> mappers;



    // Switch-like devices.

    if (classes.test(InputDeviceClass::SWITCH)) {

        mappers.push_back(std::make_unique<SwitchInputMapper>(contextPtr, readerConfig));

    }



    // Scroll wheel-like devices.

    if (classes.test(InputDeviceClass::ROTARY_ENCODER)) {

        mappers.push_back(std::make_unique<RotaryEncoderInputMapper>(contextPtr, readerConfig));

    }



    // Vibrator-like devices.

    if (classes.test(InputDeviceClass::VIBRATOR)) {

        mappers.push_back(std::make_unique<VibratorInputMapper>(contextPtr, readerConfig));

    }



    // Battery-like devices or light-containing devices.

    // PeripheralController will be created with associated EventHub device.

    if (classes.test(InputDeviceClass::BATTERY) || classes.test(InputDeviceClass::LIGHT)) {

        mController = std::make_unique<PeripheralController>(contextPtr);

    }



    // Keyboard-like devices.

    uint32_t keyboardSource = 0;

    int32_t keyboardType = AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC;

    if (classes.test(InputDeviceClass::KEYBOARD)) {

        keyboardSource |= AINPUT_SOURCE_KEYBOARD;

    }

    if (classes.test(InputDeviceClass::ALPHAKEY)) {

        keyboardType = AINPUT_KEYBOARD_TYPE_ALPHABETIC;

    }

    if (classes.test(InputDeviceClass::DPAD)) {

        keyboardSource |= AINPUT_SOURCE_DPAD;

    }

    if (classes.test(InputDeviceClass::GAMEPAD)) {

        keyboardSource |= AINPUT_SOURCE_GAMEPAD;

    }



    if (keyboardSource != 0) {

        mappers.push_back(std::make_unique<KeyboardInputMapper>(contextPtr, readerConfig,

                                                                keyboardSource, keyboardType));

    }



    // Cursor-like devices.

    if (classes.test(InputDeviceClass::CURSOR)) {

        mappers.push_back(std::make_unique<CursorInputMapper>(contextPtr, readerConfig));

    }



    // Touchscreens and touchpad devices.

    static const bool ENABLE_TOUCHPAD_GESTURES_LIBRARY =

            sysprop::InputProperties::enable_touchpad_gestures_library().value_or(true);

    // TODO(b/272518665): Fix the new touchpad stack for Sony DualShock 4 (5c4, 9cc) touchpads, or

    // at least load this setting from the IDC file.

    const InputDeviceIdentifier identifier = contextPtr.getDeviceIdentifier();

    const bool isSonyDualShock4Touchpad = identifier.vendor == 0x054c &&

            (identifier.product == 0x05c4 || identifier.product == 0x09cc);

    if (ENABLE_TOUCHPAD_GESTURES_LIBRARY && classes.test(InputDeviceClass::TOUCHPAD) &&

        classes.test(InputDeviceClass::TOUCH_MT) && !isSonyDualShock4Touchpad) {

        mappers.push_back(std::make_unique<TouchpadInputMapper>(contextPtr, readerConfig));

    } else if (classes.test(InputDeviceClass::TOUCH_MT)) {

        mappers.push_back(std::make_unique<MultiTouchInputMapper>(contextPtr, readerConfig));

    } else if (classes.test(InputDeviceClass::TOUCH)) {

        mappers.push_back(std::make_unique<SingleTouchInputMapper>(contextPtr, readerConfig));

    }



    // Joystick-like devices.

    if (classes.test(InputDeviceClass::JOYSTICK)) {

        mappers.push_back(std::make_unique<JoystickInputMapper>(contextPtr, readerConfig));

    }



    // Motion sensor enabled devices.

    if (classes.test(InputDeviceClass::SENSOR)) {

        mappers.push_back(std::make_unique<SensorInputMapper>(contextPtr, readerConfig));

    }



    // External stylus-like devices.

    if (classes.test(InputDeviceClass::EXTERNAL_STYLUS)) {

        mappers.push_back(std::make_unique<ExternalStylusInputMapper>(contextPtr, readerConfig));

    }

    return mappers;

}



bool InputDevice::markSupportedKeyCodes(uint32_t sourceMask, const std::vector<int32_t>& keyCodes,

                                        uint8_t* outFlags) {

    bool result = false;

services/inputflinger/reader/InputReader.cpp

+1 −1
Original line number Diff line number Diff line
@@ -334,7 +334,7 @@ std::shared_ptr<InputDevice> InputReader::createDeviceLocked( 
        device = std::make_shared<InputDevice>(&mContext, deviceId, bumpGenerationLocked(),

                                               identifier);

    }

    device->addEventHubDevice(eventHubId);

    device->addEventHubDevice(eventHubId, mConfig);

    return device;

}

services/inputflinger/reader/include/InputDevice.h

+7 −3
Original line number Diff line number Diff line
@@ -80,7 +80,8 @@ public: 
    [[nodiscard]] std::list<NotifyArgs> setEnabled(bool enabled, nsecs_t when);



    void dump(std::string& dump, const std::string& eventHubDevStr);

    void addEventHubDevice(int32_t eventHubId, bool populateMappers = true);

    void addEmptyEventHubDevice(int32_t eventHubId);

    void addEventHubDevice(int32_t eventHubId, const InputReaderConfiguration& readerConfig);

    void removeEventHubDevice(int32_t eventHubId);

    [[nodiscard]] std::list<NotifyArgs> configure(nsecs_t when,

                                                  const InputReaderConfiguration& readerConfig,
@@ -137,7 +138,7 @@ public: 
    template <class T, typename... Args>

    T& addMapper(int32_t eventHubId, Args... args) {

        // ensure a device entry exists for this eventHubId

        addEventHubDevice(eventHubId, false);

        addEmptyEventHubDevice(eventHubId);



        // create mapper

        auto& devicePair = mDevices[eventHubId];
@@ -152,7 +153,7 @@ public: 
    template <class T>

    T& addController(int32_t eventHubId) {

        // ensure a device entry exists for this eventHubId

        addEventHubDevice(eventHubId, false);

        addEmptyEventHubDevice(eventHubId);



        // create controller

        auto& devicePair = mDevices[eventHubId];
@@ -191,6 +192,9 @@ private: 
    typedef int32_t (InputMapper::*GetStateFunc)(uint32_t sourceMask, int32_t code);

    int32_t getState(uint32_t sourceMask, int32_t code, GetStateFunc getStateFunc);



    std::vector<std::unique_ptr<InputMapper>> createMappers(

            InputDeviceContext& contextPtr, const InputReaderConfiguration& readerConfig);



    PropertyMap mConfiguration;



    // helpers to interate over the devices collection

services/inputflinger/reader/mapper/CursorInputMapper.cpp

+131 −105
Original line number Diff line number Diff line
@@ -68,8 +68,12 @@ void CursorMotionAccumulator::finishSync() { 


// --- CursorInputMapper ---



CursorInputMapper::CursorInputMapper(InputDeviceContext& deviceContext)

      : InputMapper(deviceContext), mLastEventTime(std::numeric_limits<nsecs_t>::min()) {}

CursorInputMapper::CursorInputMapper(InputDeviceContext& deviceContext,

                                     const InputReaderConfiguration& readerConfig)

      : InputMapper(deviceContext, readerConfig),

        mLastEventTime(std::numeric_limits<nsecs_t>::min()) {

    configureWithZeroChanges(readerConfig);

}



CursorInputMapper::~CursorInputMapper() {

    if (mPointerController != nullptr) {
@@ -134,119 +138,28 @@ void CursorInputMapper::dump(std::string& dump) { 
}



std::list<NotifyArgs> CursorInputMapper::reconfigure(nsecs_t when,

                                                     const InputReaderConfiguration& config,

                                                     const InputReaderConfiguration& readerConfig,

                                                     uint32_t changes) {

    std::list<NotifyArgs> out = InputMapper::reconfigure(when, config, changes);



    if (!changes) { // first time only

        mCursorScrollAccumulator.configure(getDeviceContext());



        // Configure basic parameters.

        configureParameters();

    std::list<NotifyArgs> out = InputMapper::reconfigure(when, readerConfig, changes);



        // Configure device mode.

        switch (mParameters.mode) {

            case Parameters::Mode::POINTER_RELATIVE:

                // Should not happen during first time configuration.

                ALOGE("Cannot start a device in MODE_POINTER_RELATIVE, starting in MODE_POINTER");

                mParameters.mode = Parameters::Mode::POINTER;

                [[fallthrough]];

            case Parameters::Mode::POINTER:

                mSource = AINPUT_SOURCE_MOUSE;

                mXPrecision = 1.0f;

                mYPrecision = 1.0f;

                mXScale = 1.0f;

                mYScale = 1.0f;

                mPointerController = getContext()->getPointerController(getDeviceId());

                break;

            case Parameters::Mode::NAVIGATION:

                mSource = AINPUT_SOURCE_TRACKBALL;

                mXPrecision = TRACKBALL_MOVEMENT_THRESHOLD;

                mYPrecision = TRACKBALL_MOVEMENT_THRESHOLD;

                mXScale = 1.0f / TRACKBALL_MOVEMENT_THRESHOLD;

                mYScale = 1.0f / TRACKBALL_MOVEMENT_THRESHOLD;

                break;

        }



        mVWheelScale = 1.0f;

        mHWheelScale = 1.0f;

    if (!changes) {

        configureWithZeroChanges(readerConfig);

        return out;

    }



    const bool configurePointerCapture = mParameters.mode != Parameters::Mode::NAVIGATION &&

            ((!changes && config.pointerCaptureRequest.enable) ||

             (changes & InputReaderConfiguration::CHANGE_POINTER_CAPTURE));

            (changes & InputReaderConfiguration::CHANGE_POINTER_CAPTURE);

    if (configurePointerCapture) {

        if (config.pointerCaptureRequest.enable) {

            if (mParameters.mode == Parameters::Mode::POINTER) {

                mParameters.mode = Parameters::Mode::POINTER_RELATIVE;

                mSource = AINPUT_SOURCE_MOUSE_RELATIVE;

                // Keep PointerController around in order to preserve the pointer position.

                mPointerController->fade(PointerControllerInterface::Transition::IMMEDIATE);

            } else {

                ALOGE("Cannot request pointer capture, device is not in MODE_POINTER");

            }

        } else {

            if (mParameters.mode == Parameters::Mode::POINTER_RELATIVE) {

                mParameters.mode = Parameters::Mode::POINTER;

                mSource = AINPUT_SOURCE_MOUSE;

            } else {

                ALOGE("Cannot release pointer capture, device is not in MODE_POINTER_RELATIVE");

            }

        }

        bumpGeneration();

        if (changes) {

        configureOnPointerCapture(readerConfig);

        out.push_back(NotifyDeviceResetArgs(getContext()->getNextId(), when, getDeviceId()));

    }

    }



    if (!changes || (changes & InputReaderConfiguration::CHANGE_POINTER_SPEED) ||

        configurePointerCapture) {

        if (mParameters.mode == Parameters::Mode::POINTER_RELATIVE) {

            // Disable any acceleration or scaling for the pointer when Pointer Capture is enabled.

            mPointerVelocityControl.setParameters(FLAT_VELOCITY_CONTROL_PARAMS);

            mWheelXVelocityControl.setParameters(FLAT_VELOCITY_CONTROL_PARAMS);

            mWheelYVelocityControl.setParameters(FLAT_VELOCITY_CONTROL_PARAMS);

        } else {

            mPointerVelocityControl.setParameters(config.pointerVelocityControlParameters);

            mWheelXVelocityControl.setParameters(config.wheelVelocityControlParameters);

            mWheelYVelocityControl.setParameters(config.wheelVelocityControlParameters);

        }

    if ((changes & InputReaderConfiguration::CHANGE_POINTER_SPEED) || configurePointerCapture) {

        configureOnChangePointerSpeed(readerConfig);

    }



    if (!changes || (changes & InputReaderConfiguration::CHANGE_DISPLAY_INFO) ||

        configurePointerCapture) {

        const bool isPointer = mParameters.mode == Parameters::Mode::POINTER;



        mDisplayId = ADISPLAY_ID_NONE;

        if (auto viewport = mDeviceContext.getAssociatedViewport(); viewport) {

            // This InputDevice is associated with a viewport.

            // Only generate events for the associated display.

            const bool mismatchedPointerDisplay =

                    isPointer && (viewport->displayId != mPointerController->getDisplayId());

            mDisplayId = mismatchedPointerDisplay ? std::nullopt

                                                  : std::make_optional(viewport->displayId);

        } else if (isPointer) {

            // The InputDevice is not associated with a viewport, but it controls the mouse pointer.

            mDisplayId = mPointerController->getDisplayId();

        }



        mOrientation = ui::ROTATION_0;

        const bool isOrientedDevice =

                (mParameters.orientationAware && mParameters.hasAssociatedDisplay);

        // InputReader works in the un-rotated display coordinate space, so we don't need to do

        // anything if the device is already orientation-aware. If the device is not

        // orientation-aware, then we need to apply the inverse rotation of the display so that

        // when the display rotation is applied later as a part of the per-window transform, we

        // get the expected screen coordinates. When pointer capture is enabled, we do not apply any

        // rotations and report values directly from the input device.

        if (!isOrientedDevice && mDisplayId &&

            mParameters.mode != Parameters::Mode::POINTER_RELATIVE) {

            if (auto viewport = config.getDisplayViewportById(*mDisplayId); viewport) {

                mOrientation = getInverseRotation(viewport->orientation);

            }

        }



        bumpGeneration();

    if ((changes & InputReaderConfiguration::CHANGE_DISPLAY_INFO) || configurePointerCapture) {

        configureOnChangeDisplayInfo(readerConfig);

    }

    return out;

}
@@ -511,4 +424,117 @@ std::optional<int32_t> CursorInputMapper::getAssociatedDisplayId() { 
    return mDisplayId;

}



void CursorInputMapper::configureWithZeroChanges(const InputReaderConfiguration& readerConfig) {

    // Configuration with zero changes

    configureBasicParams();

    if (mParameters.mode != Parameters::Mode::NAVIGATION &&

        readerConfig.pointerCaptureRequest.enable) {

        configureOnPointerCapture(readerConfig);

    }

    configureOnChangePointerSpeed(readerConfig);

    configureOnChangeDisplayInfo(readerConfig);

}



void CursorInputMapper::configureBasicParams() {

    mCursorScrollAccumulator.configure(getDeviceContext());



    // Configure basic parameters.

    configureParameters();



    // Configure device mode.

    switch (mParameters.mode) {

        case Parameters::Mode::POINTER_RELATIVE:

            // Should not happen during first time configuration.

            ALOGE("Cannot start a device in MODE_POINTER_RELATIVE, starting in MODE_POINTER");

            mParameters.mode = Parameters::Mode::POINTER;

            [[fallthrough]];

        case Parameters::Mode::POINTER:

            mSource = AINPUT_SOURCE_MOUSE;

            mXPrecision = 1.0f;

            mYPrecision = 1.0f;

            mXScale = 1.0f;

            mYScale = 1.0f;

            mPointerController = getContext()->getPointerController(getDeviceId());

            break;

        case Parameters::Mode::NAVIGATION:

            mSource = AINPUT_SOURCE_TRACKBALL;

            mXPrecision = TRACKBALL_MOVEMENT_THRESHOLD;

            mYPrecision = TRACKBALL_MOVEMENT_THRESHOLD;

            mXScale = 1.0f / TRACKBALL_MOVEMENT_THRESHOLD;

            mYScale = 1.0f / TRACKBALL_MOVEMENT_THRESHOLD;

            break;

    }



    mVWheelScale = 1.0f;

    mHWheelScale = 1.0f;

}



void CursorInputMapper::configureOnPointerCapture(const InputReaderConfiguration& config) {

    if (config.pointerCaptureRequest.enable) {

        if (mParameters.mode == Parameters::Mode::POINTER) {

            mParameters.mode = Parameters::Mode::POINTER_RELATIVE;

            mSource = AINPUT_SOURCE_MOUSE_RELATIVE;

            // Keep PointerController around in order to preserve the pointer position.

            mPointerController->fade(PointerControllerInterface::Transition::IMMEDIATE);

        } else {

            ALOGE("Cannot request pointer capture, device is not in MODE_POINTER");

        }

    } else {

        if (mParameters.mode == Parameters::Mode::POINTER_RELATIVE) {

            mParameters.mode = Parameters::Mode::POINTER;

            mSource = AINPUT_SOURCE_MOUSE;

        } else {

            ALOGE("Cannot release pointer capture, device is not in MODE_POINTER_RELATIVE");

        }

    }

    bumpGeneration();

}



void CursorInputMapper::configureOnChangePointerSpeed(const InputReaderConfiguration& config) {

    if (mParameters.mode == Parameters::Mode::POINTER_RELATIVE) {

        // Disable any acceleration or scaling for the pointer when Pointer Capture is enabled.

        mPointerVelocityControl.setParameters(FLAT_VELOCITY_CONTROL_PARAMS);

        mWheelXVelocityControl.setParameters(FLAT_VELOCITY_CONTROL_PARAMS);

        mWheelYVelocityControl.setParameters(FLAT_VELOCITY_CONTROL_PARAMS);

    } else {

        mPointerVelocityControl.setParameters(config.pointerVelocityControlParameters);

        mWheelXVelocityControl.setParameters(config.wheelVelocityControlParameters);

        mWheelYVelocityControl.setParameters(config.wheelVelocityControlParameters);

    }

}



void CursorInputMapper::configureOnChangeDisplayInfo(const InputReaderConfiguration& config) {

    const bool isPointer = mParameters.mode == Parameters::Mode::POINTER;



    mDisplayId = ADISPLAY_ID_NONE;

    if (auto viewport = mDeviceContext.getAssociatedViewport(); viewport) {

        // This InputDevice is associated with a viewport.

        // Only generate events for the associated display.

        const bool mismatchedPointerDisplay =

                isPointer && (viewport->displayId != mPointerController->getDisplayId());

        mDisplayId =

                mismatchedPointerDisplay ? std::nullopt : std::make_optional(viewport->displayId);

    } else if (isPointer) {

        // The InputDevice is not associated with a viewport, but it controls the mouse pointer.

        mDisplayId = mPointerController->getDisplayId();

    }



    mOrientation = ui::ROTATION_0;

    const bool isOrientedDevice =

            (mParameters.orientationAware && mParameters.hasAssociatedDisplay);

    // InputReader works in the un-rotated display coordinate space, so we don't need to do

    // anything if the device is already orientation-aware. If the device is not

    // orientation-aware, then we need to apply the inverse rotation of the display so that

    // when the display rotation is applied later as a part of the per-window transform, we

    // get the expected screen coordinates. When pointer capture is enabled, we do not apply any

    // rotations and report values directly from the input device.

    if (!isOrientedDevice && mDisplayId && mParameters.mode != Parameters::Mode::POINTER_RELATIVE) {

        if (auto viewport = config.getDisplayViewportById(*mDisplayId); viewport) {

            mOrientation = getInverseRotation(viewport->orientation);

        }

    }



    bumpGeneration();

}



} // namespace android

services/inputflinger/reader/mapper/CursorInputMapper.h

+8 −2
Original line number Diff line number Diff line
@@ -53,14 +53,15 @@ private: 


class CursorInputMapper : public InputMapper {

public:

    explicit CursorInputMapper(InputDeviceContext& deviceContext);

    explicit CursorInputMapper(InputDeviceContext& deviceContext,

                               const InputReaderConfiguration& readerConfig);

    virtual ~CursorInputMapper();



    virtual uint32_t getSources() const override;

    virtual void populateDeviceInfo(InputDeviceInfo& deviceInfo) override;

    virtual void dump(std::string& dump) override;

    [[nodiscard]] std::list<NotifyArgs> reconfigure(nsecs_t when,

                                                    const InputReaderConfiguration& config,

                                                    const InputReaderConfiguration& readerConfig,

                                                    uint32_t changes) override;

    [[nodiscard]] std::list<NotifyArgs> reset(nsecs_t when) override;

    [[nodiscard]] std::list<NotifyArgs> process(const RawEvent* rawEvent) override;
@@ -126,6 +127,11 @@ private: 


    void configureParameters();

    void dumpParameters(std::string& dump);

    void configureWithZeroChanges(const InputReaderConfiguration& readerConfig);

    void configureBasicParams();

    void configureOnPointerCapture(const InputReaderConfiguration& config);

    void configureOnChangePointerSpeed(const InputReaderConfiguration& config);

    void configureOnChangeDisplayInfo(const InputReaderConfiguration& config);



    [[nodiscard]] std::list<NotifyArgs> sync(nsecs_t when, nsecs_t readTime);

};