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

Commit 96d53dc0 authored by Siarhei Vishniakou's avatar Siarhei Vishniakou Committed by Automerger Merge Worker
Browse files

Do not modify vector after getting references am: beb878bc 

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/native/+/15066700

Change-Id: Id7c90793f54892340a2ba63737649c1d15b05e42
parents cae2ee03 beb878bc

services/inputflinger/InputReader.cpp

+40 −40
Original line number Original line Diff line number Diff line
@@ -4332,28 +4332,28 @@ void TouchInputMapper::process(const RawEvent* rawEvent) { 
}

}





void TouchInputMapper::sync(nsecs_t when) {

void TouchInputMapper::sync(nsecs_t when) {

    const RawState* last = mRawStatesPending.empty() ?

            &mCurrentRawState : &mRawStatesPending.back();



    // Push a new state.

    // Push a new state.

    mRawStatesPending.emplace_back();

    mRawStatesPending.emplace_back();





    RawState* next = &mRawStatesPending.back();

    RawState& next = mRawStatesPending.back();

    next->clear();

    next.clear();

    next->when = when;

    next.when = when;





    // Sync button state.

    // Sync button state.

    next->buttonState = mTouchButtonAccumulator.getButtonState()

    next.buttonState = mTouchButtonAccumulator.getButtonState()

            | mCursorButtonAccumulator.getButtonState();

            | mCursorButtonAccumulator.getButtonState();





    // Sync scroll

    // Sync scroll

    next->rawVScroll = mCursorScrollAccumulator.getRelativeVWheel();

    next.rawVScroll = mCursorScrollAccumulator.getRelativeVWheel();

    next->rawHScroll = mCursorScrollAccumulator.getRelativeHWheel();

    next.rawHScroll = mCursorScrollAccumulator.getRelativeHWheel();

    mCursorScrollAccumulator.finishSync();

    mCursorScrollAccumulator.finishSync();





    // Sync touch

    // Sync touch

    syncTouch(when, next);

    syncTouch(when, &next);





    // The last RawState is actually the second to last, since we just added a new state

    const RawState& last =

            mRawStatesPending.size() == 1 ? mCurrentRawState : mRawStatesPending.rbegin()[1];

    // Assign pointer ids.

    // Assign pointer ids.

    if (!mHavePointerIds) {

    if (!mHavePointerIds) {

        assignPointerIds(last, next);

        assignPointerIds(last, next);
@@ -4362,12 +4362,12 @@ void TouchInputMapper::sync(nsecs_t when) { 
#if DEBUG_RAW_EVENTS

#if DEBUG_RAW_EVENTS

    ALOGD("syncTouch: pointerCount %d -> %d, touching ids 0x%08x -> 0x%08x, "

    ALOGD("syncTouch: pointerCount %d -> %d, touching ids 0x%08x -> 0x%08x, "

            "hovering ids 0x%08x -> 0x%08x",

            "hovering ids 0x%08x -> 0x%08x",

            last->rawPointerData.pointerCount,

            last.rawPointerData.pointerCount,

            next->rawPointerData.pointerCount,

            next.rawPointerData.pointerCount,

            last->rawPointerData.touchingIdBits.value,

            last.rawPointerData.touchingIdBits.value,

            next->rawPointerData.touchingIdBits.value,

            next.rawPointerData.touchingIdBits.value,

            last->rawPointerData.hoveringIdBits.value,

            last.rawPointerData.hoveringIdBits.value,

            next->rawPointerData.hoveringIdBits.value);

            next.rawPointerData.hoveringIdBits.value);

#endif

#endif





    processRawTouches(false /*timeout*/);

    processRawTouches(false /*timeout*/);
@@ -6612,11 +6612,11 @@ const TouchInputMapper::VirtualKey* TouchInputMapper::findVirtualKeyHit(int32_t 
    return nullptr;

    return nullptr;

}

}





void TouchInputMapper::assignPointerIds(const RawState* last, RawState* current) {

void TouchInputMapper::assignPointerIds(const RawState& last, RawState& current) {

    uint32_t currentPointerCount = current->rawPointerData.pointerCount;

    uint32_t currentPointerCount = current.rawPointerData.pointerCount;

    uint32_t lastPointerCount = last->rawPointerData.pointerCount;

    uint32_t lastPointerCount = last.rawPointerData.pointerCount;





    current->rawPointerData.clearIdBits();

    current.rawPointerData.clearIdBits();





    if (currentPointerCount == 0) {

    if (currentPointerCount == 0) {

        // No pointers to assign.

        // No pointers to assign.
@@ -6627,21 +6627,21 @@ void TouchInputMapper::assignPointerIds(const RawState* last, RawState* current) 
        // All pointers are new.

        // All pointers are new.

        for (uint32_t i = 0; i < currentPointerCount; i++) {

        for (uint32_t i = 0; i < currentPointerCount; i++) {

            uint32_t id = i;

            uint32_t id = i;

            current->rawPointerData.pointers[i].id = id;

            current.rawPointerData.pointers[i].id = id;

            current->rawPointerData.idToIndex[id] = i;

            current.rawPointerData.idToIndex[id] = i;

            current->rawPointerData.markIdBit(id, current->rawPointerData.isHovering(i));

            current.rawPointerData.markIdBit(id, current.rawPointerData.isHovering(i));

        }

        }

        return;

        return;

    }

    }





    if (currentPointerCount == 1 && lastPointerCount == 1

    if (currentPointerCount == 1 && lastPointerCount == 1

            && current->rawPointerData.pointers[0].toolType

            && current.rawPointerData.pointers[0].toolType

                    == last->rawPointerData.pointers[0].toolType) {

                    == last.rawPointerData.pointers[0].toolType) {

        // Only one pointer and no change in count so it must have the same id as before.

        // Only one pointer and no change in count so it must have the same id as before.

        uint32_t id = last->rawPointerData.pointers[0].id;

        uint32_t id = last.rawPointerData.pointers[0].id;

        current->rawPointerData.pointers[0].id = id;

        current.rawPointerData.pointers[0].id = id;

        current->rawPointerData.idToIndex[id] = 0;

        current.rawPointerData.idToIndex[id] = 0;

        current->rawPointerData.markIdBit(id, current->rawPointerData.isHovering(0));

        current.rawPointerData.markIdBit(id, current.rawPointerData.isHovering(0));

        return;

        return;

    }

    }
@@ -6659,9 +6659,9 @@ void TouchInputMapper::assignPointerIds(const RawState* last, RawState* current) 
        for (uint32_t lastPointerIndex = 0; lastPointerIndex < lastPointerCount;

        for (uint32_t lastPointerIndex = 0; lastPointerIndex < lastPointerCount;

                lastPointerIndex++) {

                lastPointerIndex++) {

            const RawPointerData::Pointer& currentPointer =

            const RawPointerData::Pointer& currentPointer =

                    current->rawPointerData.pointers[currentPointerIndex];

                    current.rawPointerData.pointers[currentPointerIndex];

            const RawPointerData::Pointer& lastPointer =

            const RawPointerData::Pointer& lastPointer =

                    last->rawPointerData.pointers[lastPointerIndex];

                    last.rawPointerData.pointers[lastPointerIndex];

            if (currentPointer.toolType == lastPointer.toolType) {

            if (currentPointer.toolType == lastPointer.toolType) {

                int64_t deltaX = currentPointer.x - lastPointer.x;

                int64_t deltaX = currentPointer.x - lastPointer.x;

                int64_t deltaY = currentPointer.y - lastPointer.y;

                int64_t deltaY = currentPointer.y - lastPointer.y;
@@ -6767,11 +6767,11 @@ void TouchInputMapper::assignPointerIds(const RawState* last, RawState* current) 
            matchedCurrentBits.markBit(currentPointerIndex);

            matchedCurrentBits.markBit(currentPointerIndex);

            matchedLastBits.markBit(lastPointerIndex);

            matchedLastBits.markBit(lastPointerIndex);





            uint32_t id = last->rawPointerData.pointers[lastPointerIndex].id;

            uint32_t id = last.rawPointerData.pointers[lastPointerIndex].id;

            current->rawPointerData.pointers[currentPointerIndex].id = id;

            current.rawPointerData.pointers[currentPointerIndex].id = id;

            current->rawPointerData.idToIndex[id] = currentPointerIndex;

            current.rawPointerData.idToIndex[id] = currentPointerIndex;

            current->rawPointerData.markIdBit(id,

            current.rawPointerData.markIdBit(id,

                    current->rawPointerData.isHovering(currentPointerIndex));

                    current.rawPointerData.isHovering(currentPointerIndex));

            usedIdBits.markBit(id);

            usedIdBits.markBit(id);





#if DEBUG_POINTER_ASSIGNMENT

#if DEBUG_POINTER_ASSIGNMENT
@@ -6788,10 +6788,10 @@ void TouchInputMapper::assignPointerIds(const RawState* last, RawState* current) 
        uint32_t currentPointerIndex = matchedCurrentBits.markFirstUnmarkedBit();

        uint32_t currentPointerIndex = matchedCurrentBits.markFirstUnmarkedBit();

        uint32_t id = usedIdBits.markFirstUnmarkedBit();

        uint32_t id = usedIdBits.markFirstUnmarkedBit();





        current->rawPointerData.pointers[currentPointerIndex].id = id;

        current.rawPointerData.pointers[currentPointerIndex].id = id;

        current->rawPointerData.idToIndex[id] = currentPointerIndex;

        current.rawPointerData.idToIndex[id] = currentPointerIndex;

        current->rawPointerData.markIdBit(id,

        current.rawPointerData.markIdBit(id,

                current->rawPointerData.isHovering(currentPointerIndex));

                current.rawPointerData.isHovering(currentPointerIndex));





#if DEBUG_POINTER_ASSIGNMENT

#if DEBUG_POINTER_ASSIGNMENT

        ALOGD("assignPointerIds - assigned: cur=%" PRIu32 ", id=%" PRIu32, currentPointerIndex, id);

        ALOGD("assignPointerIds - assigned: cur=%" PRIu32 ", id=%" PRIu32, currentPointerIndex, id);

services/inputflinger/InputReader.h

+1 −1
Original line number Original line Diff line number Diff line
@@ -1649,7 +1649,7 @@ private: 
    bool isPointInsideSurface(int32_t x, int32_t y);

    bool isPointInsideSurface(int32_t x, int32_t y);

    const VirtualKey* findVirtualKeyHit(int32_t x, int32_t y);

    const VirtualKey* findVirtualKeyHit(int32_t x, int32_t y);





    static void assignPointerIds(const RawState* last, RawState* current);

    static void assignPointerIds(const RawState& last, RawState& current);





    void reportEventForStatistics(nsecs_t evdevTime);

    void reportEventForStatistics(nsecs_t evdevTime);