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

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

Merge changes from topic "revert-16306432-revert-16295572-ORWQJPYRMQ-IQBEBXXQNX" 

* changes:
  Reland "Remove x/y offset from MotionEntry"
  Reland "Input injection: Assume transformed values are i..."
parents 9aa979b5 d6a7f221

include/input/Input.h

+2 −3
Original line number Diff line number Diff line
@@ -382,7 +382,6 @@ struct PointerCoords { 
    // window scale. The global scale will be applied to TOUCH/TOOL_MAJOR/MINOR

    // axes, however the window scaling will not.

    void scale(float globalScale, float windowXScale, float windowYScale);

    void applyOffset(float xOffset, float yOffset);



    void transform(const ui::Transform& transform);
@@ -572,7 +571,7 @@ public: 


    inline float getYOffset() const { return mTransform.ty(); }



    inline ui::Transform getTransform() const { return mTransform; }

    inline const ui::Transform& getTransform() const { return mTransform; }



    int getSurfaceRotation() const;
@@ -590,7 +589,7 @@ public: 


    void setCursorPosition(float x, float y);



    ui::Transform getRawTransform() const { return mRawTransform; }

    inline const ui::Transform& getRawTransform() const { return mRawTransform; }



    static inline bool isValidCursorPosition(float x, float y) { return !isnan(x) && !isnan(y); }

libs/input/Input.cpp

+0 −5
Original line number Diff line number Diff line
@@ -344,11 +344,6 @@ void PointerCoords::scale(float globalScaleFactor, float windowXScale, float win 
    scaleAxisValue(*this, AMOTION_EVENT_AXIS_RELATIVE_Y, windowYScale);

}



void PointerCoords::applyOffset(float xOffset, float yOffset) {

    setAxisValue(AMOTION_EVENT_AXIS_X, getX() + xOffset);

    setAxisValue(AMOTION_EVENT_AXIS_Y, getY() + yOffset);

}



#ifdef __linux__

status_t PointerCoords::readFromParcel(Parcel* parcel) {

    bits = parcel->readInt64();

services/inputflinger/dispatcher/Entry.cpp

+1 −4
Original line number Diff line number Diff line
@@ -214,7 +214,7 @@ MotionEntry::MotionEntry(int32_t id, nsecs_t eventTime, int32_t deviceId, uint32 
                         int32_t edgeFlags, float xPrecision, float yPrecision,

                         float xCursorPosition, float yCursorPosition, nsecs_t downTime,

                         uint32_t pointerCount, const PointerProperties* pointerProperties,

                         const PointerCoords* pointerCoords, float xOffset, float yOffset)

                         const PointerCoords* pointerCoords)

      : EventEntry(id, Type::MOTION, eventTime, policyFlags),

        deviceId(deviceId),

        source(source),
@@ -235,9 +235,6 @@ MotionEntry::MotionEntry(int32_t id, nsecs_t eventTime, int32_t deviceId, uint32 
    for (uint32_t i = 0; i < pointerCount; i++) {

        this->pointerProperties[i].copyFrom(pointerProperties[i]);

        this->pointerCoords[i].copyFrom(pointerCoords[i]);

        if (xOffset || yOffset) {

            this->pointerCoords[i].applyOffset(xOffset, yOffset);

        }

    }

}

services/inputflinger/dispatcher/Entry.h

+1 −2
Original line number Diff line number Diff line
@@ -184,8 +184,7 @@ struct MotionEntry : EventEntry { 
                int32_t metaState, int32_t buttonState, MotionClassification classification,

                int32_t edgeFlags, float xPrecision, float yPrecision, float xCursorPosition,

                float yCursorPosition, nsecs_t downTime, uint32_t pointerCount,

                const PointerProperties* pointerProperties, const PointerCoords* pointerCoords,

                float xOffset, float yOffset);

                const PointerProperties* pointerProperties, const PointerCoords* pointerCoords);

    std::string getDescription() const override;



    ~MotionEntry() override;

services/inputflinger/dispatcher/InputDispatcher.cpp

+23 −38
Original line number Diff line number Diff line
@@ -378,7 +378,7 @@ std::unique_ptr<DispatchEntry> createDispatchEntry(const InputTarget& inputTarge 
                                          motionEntry.yPrecision, motionEntry.xCursorPosition,

                                          motionEntry.yCursorPosition, motionEntry.downTime,

                                          motionEntry.pointerCount, motionEntry.pointerProperties,

                                          pointerCoords.data(), 0 /* xOffset */, 0 /* yOffset */);

                                          pointerCoords.data());



    if (motionEntry.injectionState) {

        combinedMotionEntry->injectionState = motionEntry.injectionState;
@@ -506,12 +506,6 @@ bool isConnectionResponsive(const Connection& connection) { 
    return true;

}



vec2 transformWithoutTranslation(const ui::Transform& transform, float x, float y) {

    const vec2 transformedXy = transform.transform(x, y);

    const vec2 transformedOrigin = transform.transform(0, 0);

    return transformedXy - transformedOrigin;

}



// Returns true if the event type passed as argument represents a user activity.

bool isUserActivityEvent(const EventEntry& eventEntry) {

    switch (eventEntry.type) {
@@ -3763,7 +3757,7 @@ std::unique_ptr<MotionEntry> InputDispatcher::splitMotionEvent( 
                                          originalMotionEntry.xCursorPosition,

                                          originalMotionEntry.yCursorPosition,

                                          originalMotionEntry.downTime, splitPointerCount,

                                          splitPointerProperties, splitPointerCoords, 0, 0);

                                          splitPointerProperties, splitPointerCoords);



    if (originalMotionEntry.injectionState) {

        splitMotionEntry->injectionState = originalMotionEntry.injectionState;
@@ -3989,7 +3983,7 @@ void InputDispatcher::notifyMotion(const NotifyMotionArgs* args) { 
                                              args->xPrecision, args->yPrecision,

                                              args->xCursorPosition, args->yCursorPosition,

                                              args->downTime, args->pointerCount,

                                              args->pointerProperties, args->pointerCoords, 0, 0);

                                              args->pointerProperties, args->pointerCoords);



        if (args->id != android::os::IInputConstants::INVALID_INPUT_EVENT_ID &&

            IdGenerator::getSource(args->id) == IdGenerator::Source::INPUT_READER &&
@@ -4219,10 +4213,8 @@ InputEventInjectionResult InputDispatcher::injectInputEvent( 
                                                  motionEvent.getRawXCursorPosition(),

                                                  motionEvent.getRawYCursorPosition(),

                                                  motionEvent.getDownTime(), uint32_t(pointerCount),

                                                  pointerProperties, samplePointerCoords,

                                                  motionEvent.getXOffset(),

                                                  motionEvent.getYOffset());

            transformMotionEntryForInjectionLocked(*injectedEntry);

                                                  pointerProperties, samplePointerCoords);

            transformMotionEntryForInjectionLocked(*injectedEntry, motionEvent.getTransform());

            injectedEntries.push(std::move(injectedEntry));

            for (size_t i = motionEvent.getHistorySize(); i > 0; i--) {

                sampleEventTimes += 1;
@@ -4241,9 +4233,9 @@ InputEventInjectionResult InputDispatcher::injectInputEvent( 
                                                      motionEvent.getRawYCursorPosition(),

                                                      motionEvent.getDownTime(),

                                                      uint32_t(pointerCount), pointerProperties,

                                                      samplePointerCoords, motionEvent.getXOffset(),

                                                      motionEvent.getYOffset());

                transformMotionEntryForInjectionLocked(*nextInjectedEntry);

                                                      samplePointerCoords);

                transformMotionEntryForInjectionLocked(*nextInjectedEntry,

                                                       motionEvent.getTransform());

                injectedEntries.push(std::move(nextInjectedEntry));

            }

            break;
@@ -4407,35 +4399,28 @@ void InputDispatcher::setInjectionResult(EventEntry& entry, 
    }

}



void InputDispatcher::transformMotionEntryForInjectionLocked(MotionEntry& entry) const {

    const bool isRelativeMouseEvent = isFromSource(entry.source, AINPUT_SOURCE_MOUSE_RELATIVE);

    if (!isRelativeMouseEvent && !isFromSource(entry.source, AINPUT_SOURCE_CLASS_POINTER)) {

        return;

    }



void InputDispatcher::transformMotionEntryForInjectionLocked(

        MotionEntry& entry, const ui::Transform& injectedTransform) const {

    // Input injection works in the logical display coordinate space, but the input pipeline works

    // display space, so we need to transform the injected events accordingly.

    const auto it = mDisplayInfos.find(entry.displayId);

    if (it == mDisplayInfos.end()) return;

    const auto& transformToDisplay = it->second.transform.inverse();

    const auto& transformToDisplay = it->second.transform.inverse() * injectedTransform;



    for (uint32_t i = 0; i < entry.pointerCount; i++) {

        PointerCoords& pc = entry.pointerCoords[i];

        const auto xy = isRelativeMouseEvent

                ? transformWithoutTranslation(transformToDisplay, pc.getX(), pc.getY())

                : transformToDisplay.transform(pc.getXYValue());

        pc.setAxisValue(AMOTION_EVENT_AXIS_X, xy.x);

        pc.setAxisValue(AMOTION_EVENT_AXIS_Y, xy.y);



        // Axes with relative values never represent points on a screen, so they should never have

        // translation applied. If a device does not report relative values, these values are always

        // 0, and will remain unaffected by the following operation.

        const auto rel =

                transformWithoutTranslation(transformToDisplay,

                                            pc.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X),

                                            pc.getAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y));

        pc.setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_X, rel.x);

        pc.setAxisValue(AMOTION_EVENT_AXIS_RELATIVE_Y, rel.y);

        // Make a copy of the injected coords. We cannot change them in place because some of them

        // are interdependent (for example, X coordinate might depend on the Y coordinate).

        PointerCoords injectedCoords = entry.pointerCoords[i];



        BitSet64 bits(injectedCoords.bits);

        while (!bits.isEmpty()) {

            const auto axis = static_cast<int32_t>(bits.clearFirstMarkedBit());

            const float value =

                    MotionEvent::calculateTransformedAxisValue(axis, entry.source,

                                                               transformToDisplay, injectedCoords);

            pc.setAxisValue(axis, value);

        }

    }

}