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

Commit cce7e112 authored by Siarhei Vishniakou's avatar Siarhei Vishniakou
Browse files

Separate logic for publishing motion events 

Before a motion event is published, there's some more processing
happening, such as determining which coords should be used.
Let's move that into a separate function to make it more tractable.

Bug: 211379801
Test: atest inputflinger_tests
Change-Id: If373305b546c461e22e4b496d66418f771e9e741
parent 34014048

services/inputflinger/dispatcher/InputDispatcher.cpp

+50 −52
Original line number Original line Diff line number Diff line
@@ -3205,6 +3205,55 @@ void InputDispatcher::dispatchPointerDownOutsideFocus(uint32_t source, int32_t a 
    postCommandLocked(std::move(command));

    postCommandLocked(std::move(command));

}

}





status_t InputDispatcher::publishMotionEvent(Connection& connection,

                                             DispatchEntry& dispatchEntry) const {

    const EventEntry& eventEntry = *(dispatchEntry.eventEntry);

    const MotionEntry& motionEntry = static_cast<const MotionEntry&>(eventEntry);



    PointerCoords scaledCoords[MAX_POINTERS];

    const PointerCoords* usingCoords = motionEntry.pointerCoords;



    // Set the X and Y offset and X and Y scale depending on the input source.

    if ((motionEntry.source & AINPUT_SOURCE_CLASS_POINTER) &&

        !(dispatchEntry.targetFlags & InputTarget::FLAG_ZERO_COORDS)) {

        float globalScaleFactor = dispatchEntry.globalScaleFactor;

        if (globalScaleFactor != 1.0f) {

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

                scaledCoords[i] = motionEntry.pointerCoords[i];

                // 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 if (dispatchEntry.targetFlags & InputTarget::FLAG_ZERO_COORDS) {

        // We don't want the dispatch target to know the coordinates

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

            scaledCoords[i].clear();

        }

        usingCoords = scaledCoords;

    }



    std::array<uint8_t, 32> hmac = getSignature(motionEntry, dispatchEntry);



    // Publish the motion event.

    return connection.inputPublisher

            .publishMotionEvent(dispatchEntry.seq, dispatchEntry.resolvedEventId,

                                motionEntry.deviceId, motionEntry.source, motionEntry.displayId,

                                std::move(hmac), dispatchEntry.resolvedAction,

                                motionEntry.actionButton, dispatchEntry.resolvedFlags,

                                motionEntry.edgeFlags, motionEntry.metaState,

                                motionEntry.buttonState, motionEntry.classification,

                                dispatchEntry.transform, motionEntry.xPrecision,

                                motionEntry.yPrecision, motionEntry.xCursorPosition,

                                motionEntry.yCursorPosition, dispatchEntry.rawTransform,

                                motionEntry.downTime, motionEntry.eventTime,

                                motionEntry.pointerCount, motionEntry.pointerProperties,

                                usingCoords);

}



void InputDispatcher::startDispatchCycleLocked(nsecs_t currentTime,

void InputDispatcher::startDispatchCycleLocked(nsecs_t currentTime,

                                               const sp<Connection>& connection) {

                                               const sp<Connection>& connection) {

    if (ATRACE_ENABLED()) {

    if (ATRACE_ENABLED()) {
@@ -3244,58 +3293,7 @@ void InputDispatcher::startDispatchCycleLocked(nsecs_t currentTime, 
            }

            }





            case EventEntry::Type::MOTION: {

            case EventEntry::Type::MOTION: {

                const MotionEntry& motionEntry = static_cast<const MotionEntry&>(eventEntry);

                status = publishMotionEvent(*connection, *dispatchEntry);



                PointerCoords scaledCoords[MAX_POINTERS];

                const PointerCoords* usingCoords = motionEntry.pointerCoords;



                // Set the X and Y offset and X and Y scale depending on the input source.

                if ((motionEntry.source & AINPUT_SOURCE_CLASS_POINTER) &&

                    !(dispatchEntry->targetFlags & InputTarget::FLAG_ZERO_COORDS)) {

                    float globalScaleFactor = dispatchEntry->globalScaleFactor;

                    if (globalScaleFactor != 1.0f) {

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

                            scaledCoords[i] = motionEntry.pointerCoords[i];

                            // 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 {

                    // 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++) {

                            scaledCoords[i].clear();

                        }

                        usingCoords = scaledCoords;

                    }

                }



                std::array<uint8_t, 32> hmac = getSignature(motionEntry, *dispatchEntry);



                // Publish the motion event.

                status = connection->inputPublisher

                                 .publishMotionEvent(dispatchEntry->seq,

                                                     dispatchEntry->resolvedEventId,

                                                     motionEntry.deviceId, motionEntry.source,

                                                     motionEntry.displayId, std::move(hmac),

                                                     dispatchEntry->resolvedAction,

                                                     motionEntry.actionButton,

                                                     dispatchEntry->resolvedFlags,

                                                     motionEntry.edgeFlags, motionEntry.metaState,

                                                     motionEntry.buttonState,

                                                     motionEntry.classification,

                                                     dispatchEntry->transform,

                                                     motionEntry.xPrecision, motionEntry.yPrecision,

                                                     motionEntry.xCursorPosition,

                                                     motionEntry.yCursorPosition,

                                                     dispatchEntry->rawTransform,

                                                     motionEntry.downTime, motionEntry.eventTime,

                                                     motionEntry.pointerCount,

                                                     motionEntry.pointerProperties, usingCoords);

                break;

                break;

            }

            }

services/inputflinger/dispatcher/InputDispatcher.h

+1 −0
Original line number Original line Diff line number Diff line
@@ -601,6 +601,7 @@ private: 
    void enqueueDispatchEntryLocked(const sp<Connection>& connection, std::shared_ptr<EventEntry>,

    void enqueueDispatchEntryLocked(const sp<Connection>& connection, std::shared_ptr<EventEntry>,

                                    const InputTarget& inputTarget, int32_t dispatchMode)

                                    const InputTarget& inputTarget, int32_t dispatchMode)

            REQUIRES(mLock);

            REQUIRES(mLock);

    status_t publishMotionEvent(Connection& connection, DispatchEntry& dispatchEntry) const;

    void startDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection)

    void startDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection)

            REQUIRES(mLock);

            REQUIRES(mLock);

    void finishDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,

    void finishDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,