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

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

Ensure channel receives a consistent touch stream 

Add an event verifier to check the touch streams that are being sent to
the input channel.

If a stream is inconsistent, crash.

For now, only touch streams are being verified. Disable the feature
while the bugs are being fixed.

Bug: 267082966
Test: m inputflinger_tests && $ANDROID_HOST_OUT/nativetest64/inputflinger_tests/inputflinger_tests
Change-Id: Ibb8ab70b0019789c1a17dae0077be6b23d3d9139
parent 5c6d6863

include/input/InputTransport.h

+2 −0
Original line number Diff line number Diff line
@@ -38,6 +38,7 @@ 
#include <binder/IBinder.h>

#include <binder/Parcelable.h>

#include <input/Input.h>

#include <input/InputVerifier.h>

#include <sys/stat.h>

#include <ui/Transform.h>

#include <utils/BitSet.h>
@@ -444,6 +445,7 @@ public: 


private:

    std::shared_ptr<InputChannel> mChannel;

    InputVerifier mInputVerifier;

};



/*

include/input/InputVerifier.h

0 → 100644
+49 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2023 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#pragma once



#include <input/Input.h>

#include <map>



namespace android {



/*

 * Crash if the provided touch stream is inconsistent.

 *

 * TODO(b/211379801): Add support for hover events:

 * - No hover move without enter

 * - No touching pointers when hover enter

 * - No hovering pointers when touching

 * - Only 1 hovering pointer max

 */

class InputVerifier {

public:

    InputVerifier(const std::string& name);



    void processMovement(int32_t deviceId, int32_t action, uint32_t pointerCount,

                         const PointerProperties* pointerProperties,

                         const PointerCoords* pointerCoords, int32_t flags);



private:

    const std::string mName;

    std::map<int32_t /*deviceId*/, std::bitset<MAX_POINTER_ID + 1>> mTouchingPointerIdsByDevice;

    void ensureTouchingPointersMatch(int32_t deviceId, uint32_t pointerCount,

                                     const PointerProperties* pointerProperties,

                                     const char* action) const;

};



} // namespace android

libs/input/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -47,6 +47,7 @@ cc_library { 
        "Input.cpp",

        "InputDevice.cpp",

        "InputEventLabels.cpp",

        "InputVerifier.cpp",

        "Keyboard.cpp",

        "KeyCharacterMap.cpp",

        "KeyLayoutMap.cpp",

libs/input/InputTransport.cpp

+14 −1
Original line number Diff line number Diff line
@@ -76,6 +76,14 @@ static const nsecs_t RESAMPLE_MAX_PREDICTION = 8 * NANOS_PER_MS; 
 */

static const char* PROPERTY_RESAMPLING_ENABLED = "ro.input.resampling";



/**

 * Crash if the events that are getting sent to the InputPublisher are inconsistent.

 * Enable this via "adb shell setprop log.tag.InputTransportVerifyEvents DEBUG"

 */

static bool verifyEvents() {

    return __android_log_is_loggable(ANDROID_LOG_DEBUG, LOG_TAG "VerifyEvents", ANDROID_LOG_INFO);

}



template<typename T>

inline static T min(const T& a, const T& b) {

    return a < b ? a : b;
@@ -492,7 +500,8 @@ base::unique_fd InputChannel::dupFd() const { 


// --- InputPublisher ---



InputPublisher::InputPublisher(const std::shared_ptr<InputChannel>& channel) : mChannel(channel) {}

InputPublisher::InputPublisher(const std::shared_ptr<InputChannel>& channel)

      : mChannel(channel), mInputVerifier(channel->getName()) {}



InputPublisher::~InputPublisher() {

}
@@ -555,6 +564,10 @@ status_t InputPublisher::publishMotionEvent( 
                mChannel->getName().c_str(), action);

        ATRACE_NAME(message.c_str());

    }

    if (verifyEvents()) {

        mInputVerifier.processMovement(deviceId, action, pointerCount, pointerProperties,

                                       pointerCoords, flags);

    }

    if (DEBUG_TRANSPORT_ACTIONS) {

        std::string transformString;

        transform.dump(transformString, "transform", "        ");

libs/input/InputVerifier.cpp

0 → 100644
+128 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2023 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#define LOG_TAG "InputVerifier"



#include <android-base/logging.h>

#include <input/InputVerifier.h>



namespace android {



/**

 * Log all of the movements that are sent to this verifier. Helps to identify the streams that lead

 * to inconsistent events.

 * Enable this via "adb shell setprop log.tag.InputVerifierLogEvents DEBUG"

 */

static bool logEvents() {

    return __android_log_is_loggable(ANDROID_LOG_DEBUG, LOG_TAG "LogEvents", ANDROID_LOG_INFO);

}



// --- InputVerifier ---



InputVerifier::InputVerifier(const std::string& name) : mName(name){};



void InputVerifier::processMovement(int32_t deviceId, int32_t action, uint32_t pointerCount,

                                    const PointerProperties* pointerProperties,

                                    const PointerCoords* pointerCoords, int32_t flags) {

    if (logEvents()) {

        LOG(ERROR) << "Processing " << MotionEvent::actionToString(action) << " for device "

                   << deviceId << " (" << pointerCount << " pointer"

                   << (pointerCount == 1 ? "" : "s") << ") on " << mName;

    }



    switch (MotionEvent::getActionMasked(action)) {

        case AMOTION_EVENT_ACTION_DOWN: {

            auto [it, inserted] = mTouchingPointerIdsByDevice.insert({deviceId, {}});

            if (!inserted) {

                LOG(FATAL) << "Got ACTION_DOWN, but already have touching pointers " << it->second

                           << " for device " << deviceId << " on " << mName;

            }

            it->second.set(pointerProperties[0].id);

            break;

        }

        case AMOTION_EVENT_ACTION_POINTER_DOWN: {

            auto it = mTouchingPointerIdsByDevice.find(deviceId);

            if (it == mTouchingPointerIdsByDevice.end()) {

                LOG(FATAL) << "Got POINTER_DOWN, but no touching pointers for device " << deviceId

                           << " on " << mName;

            }

            it->second.set(pointerProperties[MotionEvent::getActionIndex(action)].id);

            break;

        }

        case AMOTION_EVENT_ACTION_MOVE: {

            ensureTouchingPointersMatch(deviceId, pointerCount, pointerProperties, "MOVE");

            break;

        }

        case AMOTION_EVENT_ACTION_POINTER_UP: {

            auto it = mTouchingPointerIdsByDevice.find(deviceId);

            if (it == mTouchingPointerIdsByDevice.end()) {

                LOG(FATAL) << "Got POINTER_UP, but no touching pointers for device " << deviceId

                           << " on " << mName;

            }

            it->second.reset(pointerProperties[MotionEvent::getActionIndex(action)].id);

            break;

        }

        case AMOTION_EVENT_ACTION_UP: {

            auto it = mTouchingPointerIdsByDevice.find(deviceId);

            if (it == mTouchingPointerIdsByDevice.end()) {

                LOG(FATAL) << "Got ACTION_UP, but no record for deviceId " << deviceId << " on "

                           << mName;

            }

            const auto& [_, touchingPointerIds] = *it;

            if (touchingPointerIds.count() != 1) {

                LOG(FATAL) << "Got ACTION_UP, but we have pointers: " << touchingPointerIds

                           << " for deviceId " << deviceId << " on " << mName;

            }

            const int32_t pointerId = pointerProperties[0].id;

            if (!touchingPointerIds.test(pointerId)) {

                LOG(FATAL) << "Got ACTION_UP, but pointerId " << pointerId

                           << " is not touching. Touching pointers: " << touchingPointerIds

                           << " for deviceId " << deviceId << " on " << mName;

            }

            mTouchingPointerIdsByDevice.erase(it);

            break;

        }

        case AMOTION_EVENT_ACTION_CANCEL: {

            if ((flags & AMOTION_EVENT_FLAG_CANCELED) != AMOTION_EVENT_FLAG_CANCELED) {

                LOG(FATAL) << "For ACTION_CANCEL, must set FLAG_CANCELED";

            }

            ensureTouchingPointersMatch(deviceId, pointerCount, pointerProperties, "CANCEL");

            mTouchingPointerIdsByDevice.erase(deviceId);

            break;

        }

    }

}



void InputVerifier::ensureTouchingPointersMatch(int32_t deviceId, uint32_t pointerCount,

                                                const PointerProperties* pointerProperties,

                                                const char* action) const {

    auto it = mTouchingPointerIdsByDevice.find(deviceId);

    if (it == mTouchingPointerIdsByDevice.end()) {

        LOG(FATAL) << "Got " << action << ", but no touching pointers for device " << deviceId

                   << " on " << mName;

    }

    const auto& [_, touchingPointerIds] = *it;

    for (size_t i = 0; i < pointerCount; i++) {

        const int32_t pointerId = pointerProperties[i].id;

        if (!touchingPointerIds.test(pointerId)) {

            LOG(FATAL) << "Got " << action << " for pointerId " << pointerId

                       << " but the touching pointers are " << touchingPointerIds << " on "

                       << mName;

        }

    }

};



} // namespace android