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

Commit 9205e42f authored by Prabir Pradhan's avatar Prabir Pradhan
Browse files

inputflinger_tests: Add EventBuilders header 

Bug: 275726706
Test: atest inputflinger_tests
Change-Id: Ic51250da610a2d5a039b1a475fb4db48e90e9af0
parent 852db897

services/inputflinger/tests/EventBuilders.h

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

 * Copyright 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 <NotifyArgs.h>

#include <android/input.h>

#include <attestation/HmacKeyManager.h>

#include <input/Input.h>

#include <vector>



namespace android {



// An arbitrary device id.

static constexpr uint32_t DEFAULT_DEVICE_ID = 1;



// The default policy flags to use for event injection by tests.

static constexpr uint32_t DEFAULT_POLICY_FLAGS = POLICY_FLAG_FILTERED | POLICY_FLAG_PASS_TO_USER;



class PointerBuilder {

public:

    PointerBuilder(int32_t id, ToolType toolType) {

        mProperties.clear();

        mProperties.id = id;

        mProperties.toolType = toolType;

        mCoords.clear();

    }



    PointerBuilder& x(float x) { return axis(AMOTION_EVENT_AXIS_X, x); }



    PointerBuilder& y(float y) { return axis(AMOTION_EVENT_AXIS_Y, y); }



    PointerBuilder& axis(int32_t axis, float value) {

        mCoords.setAxisValue(axis, value);

        return *this;

    }



    PointerProperties buildProperties() const { return mProperties; }



    PointerCoords buildCoords() const { return mCoords; }



private:

    PointerProperties mProperties;

    PointerCoords mCoords;

};



class MotionEventBuilder {

public:

    MotionEventBuilder(int32_t action, int32_t source) {

        mAction = action;

        mSource = source;

        mEventTime = systemTime(SYSTEM_TIME_MONOTONIC);

        mDownTime = mEventTime;

    }



    MotionEventBuilder& deviceId(int32_t deviceId) {

        mDeviceId = deviceId;

        return *this;

    }



    MotionEventBuilder& downTime(nsecs_t downTime) {

        mDownTime = downTime;

        return *this;

    }



    MotionEventBuilder& eventTime(nsecs_t eventTime) {

        mEventTime = eventTime;

        return *this;

    }



    MotionEventBuilder& displayId(int32_t displayId) {

        mDisplayId = displayId;

        return *this;

    }



    MotionEventBuilder& actionButton(int32_t actionButton) {

        mActionButton = actionButton;

        return *this;

    }



    MotionEventBuilder& buttonState(int32_t buttonState) {

        mButtonState = buttonState;

        return *this;

    }



    MotionEventBuilder& rawXCursorPosition(float rawXCursorPosition) {

        mRawXCursorPosition = rawXCursorPosition;

        return *this;

    }



    MotionEventBuilder& rawYCursorPosition(float rawYCursorPosition) {

        mRawYCursorPosition = rawYCursorPosition;

        return *this;

    }



    MotionEventBuilder& pointer(PointerBuilder pointer) {

        mPointers.push_back(pointer);

        return *this;

    }



    MotionEventBuilder& addFlag(uint32_t flags) {

        mFlags |= flags;

        return *this;

    }



    MotionEvent build() {

        std::vector<PointerProperties> pointerProperties;

        std::vector<PointerCoords> pointerCoords;

        for (const PointerBuilder& pointer : mPointers) {

            pointerProperties.push_back(pointer.buildProperties());

            pointerCoords.push_back(pointer.buildCoords());

        }



        // Set mouse cursor position for the most common cases to avoid boilerplate.

        if (mSource == AINPUT_SOURCE_MOUSE &&

            !MotionEvent::isValidCursorPosition(mRawXCursorPosition, mRawYCursorPosition)) {

            mRawXCursorPosition = pointerCoords[0].getX();

            mRawYCursorPosition = pointerCoords[0].getY();

        }



        MotionEvent event;

        static const ui::Transform kIdentityTransform;

        event.initialize(InputEvent::nextId(), mDeviceId, mSource, mDisplayId, INVALID_HMAC,

                         mAction, mActionButton, mFlags, /*edgeFlags=*/0, AMETA_NONE, mButtonState,

                         MotionClassification::NONE, kIdentityTransform,

                         /*xPrecision=*/0, /*yPrecision=*/0, mRawXCursorPosition,

                         mRawYCursorPosition, kIdentityTransform, mDownTime, mEventTime,

                         mPointers.size(), pointerProperties.data(), pointerCoords.data());

        return event;

    }



private:

    int32_t mAction;

    int32_t mDeviceId{DEFAULT_DEVICE_ID};

    int32_t mSource;

    nsecs_t mDownTime;

    nsecs_t mEventTime;

    int32_t mDisplayId{ADISPLAY_ID_DEFAULT};

    int32_t mActionButton{0};

    int32_t mButtonState{0};

    int32_t mFlags{0};

    float mRawXCursorPosition{AMOTION_EVENT_INVALID_CURSOR_POSITION};

    float mRawYCursorPosition{AMOTION_EVENT_INVALID_CURSOR_POSITION};



    std::vector<PointerBuilder> mPointers;

};



class MotionArgsBuilder {

public:

    MotionArgsBuilder(int32_t action, int32_t source) {

        mAction = action;

        mSource = source;

        mEventTime = systemTime(SYSTEM_TIME_MONOTONIC);

        mDownTime = mEventTime;

    }



    MotionArgsBuilder& deviceId(int32_t deviceId) {

        mDeviceId = deviceId;

        return *this;

    }



    MotionArgsBuilder& downTime(nsecs_t downTime) {

        mDownTime = downTime;

        return *this;

    }



    MotionArgsBuilder& eventTime(nsecs_t eventTime) {

        mEventTime = eventTime;

        return *this;

    }



    MotionArgsBuilder& displayId(int32_t displayId) {

        mDisplayId = displayId;

        return *this;

    }



    MotionArgsBuilder& policyFlags(int32_t policyFlags) {

        mPolicyFlags = policyFlags;

        return *this;

    }



    MotionArgsBuilder& actionButton(int32_t actionButton) {

        mActionButton = actionButton;

        return *this;

    }



    MotionArgsBuilder& buttonState(int32_t buttonState) {

        mButtonState = buttonState;

        return *this;

    }



    MotionArgsBuilder& rawXCursorPosition(float rawXCursorPosition) {

        mRawXCursorPosition = rawXCursorPosition;

        return *this;

    }



    MotionArgsBuilder& rawYCursorPosition(float rawYCursorPosition) {

        mRawYCursorPosition = rawYCursorPosition;

        return *this;

    }



    MotionArgsBuilder& pointer(PointerBuilder pointer) {

        mPointers.push_back(pointer);

        return *this;

    }



    MotionArgsBuilder& addFlag(uint32_t flags) {

        mFlags |= flags;

        return *this;

    }



    MotionArgsBuilder& classification(MotionClassification classification) {

        mClassification = classification;

        return *this;

    }



    NotifyMotionArgs build() {

        std::vector<PointerProperties> pointerProperties;

        std::vector<PointerCoords> pointerCoords;

        for (const PointerBuilder& pointer : mPointers) {

            pointerProperties.push_back(pointer.buildProperties());

            pointerCoords.push_back(pointer.buildCoords());

        }



        // Set mouse cursor position for the most common cases to avoid boilerplate.

        if (mSource == AINPUT_SOURCE_MOUSE &&

            !MotionEvent::isValidCursorPosition(mRawXCursorPosition, mRawYCursorPosition)) {

            mRawXCursorPosition = pointerCoords[0].getX();

            mRawYCursorPosition = pointerCoords[0].getY();

        }



        return {InputEvent::nextId(),

                mEventTime,

                /*readTime=*/mEventTime,

                mDeviceId,

                mSource,

                mDisplayId,

                mPolicyFlags,

                mAction,

                mActionButton,

                mFlags,

                AMETA_NONE,

                mButtonState,

                mClassification,

                /*edgeFlags=*/0,

                static_cast<uint32_t>(mPointers.size()),

                pointerProperties.data(),

                pointerCoords.data(),

                /*xPrecision=*/0,

                /*yPrecision=*/0,

                mRawXCursorPosition,

                mRawYCursorPosition,

                mDownTime,

                /*videoFrames=*/{}};

    }



private:

    int32_t mAction;

    int32_t mDeviceId{DEFAULT_DEVICE_ID};

    uint32_t mSource;

    nsecs_t mDownTime;

    nsecs_t mEventTime;

    int32_t mDisplayId{ADISPLAY_ID_DEFAULT};

    uint32_t mPolicyFlags = DEFAULT_POLICY_FLAGS;

    int32_t mActionButton{0};

    int32_t mButtonState{0};

    int32_t mFlags{0};

    MotionClassification mClassification{MotionClassification::NONE};

    float mRawXCursorPosition{AMOTION_EVENT_INVALID_CURSOR_POSITION};

    float mRawYCursorPosition{AMOTION_EVENT_INVALID_CURSOR_POSITION};



    std::vector<PointerBuilder> mPointers;

};



} // namespace android

services/inputflinger/tests/InputDispatcher_test.cpp

+2 −245
Original line number Diff line number Diff line
@@ -15,6 +15,7 @@ 
 */



#include "../dispatcher/InputDispatcher.h"

#include "EventBuilders.h"



#include <android-base/properties.h>

#include <android-base/silent_death_test.h>
@@ -51,7 +52,7 @@ using testing::AllOf; 
static constexpr nsecs_t ARBITRARY_TIME = 1234;



// An arbitrary device id.

static constexpr int32_t DEVICE_ID = 1;

static constexpr int32_t DEVICE_ID = DEFAULT_DEVICE_ID;

static constexpr int32_t SECOND_DEVICE_ID = 2;



// An arbitrary display id.
@@ -97,9 +98,6 @@ static constexpr int32_t WINDOW_UID = 1001; 
static constexpr int32_t SECONDARY_WINDOW_PID = 1010;

static constexpr int32_t SECONDARY_WINDOW_UID = 1012;



// The default policy flags to use for event injection by tests.

static constexpr uint32_t DEFAULT_POLICY_FLAGS = POLICY_FLAG_FILTERED | POLICY_FLAG_PASS_TO_USER;



// An arbitrary pid of the gesture monitor window

static constexpr int32_t MONITOR_PID = 2001;
@@ -1468,247 +1466,6 @@ static InputEventInjectionResult injectKeyUp(const std::unique_ptr<InputDispatch 
    return injectKey(dispatcher, AKEY_EVENT_ACTION_UP, /*repeatCount=*/0, displayId);

}



class PointerBuilder {

public:

    PointerBuilder(int32_t id, ToolType toolType) {

        mProperties.clear();

        mProperties.id = id;

        mProperties.toolType = toolType;

        mCoords.clear();

    }



    PointerBuilder& x(float x) { return axis(AMOTION_EVENT_AXIS_X, x); }



    PointerBuilder& y(float y) { return axis(AMOTION_EVENT_AXIS_Y, y); }



    PointerBuilder& axis(int32_t axis, float value) {

        mCoords.setAxisValue(axis, value);

        return *this;

    }



    PointerProperties buildProperties() const { return mProperties; }



    PointerCoords buildCoords() const { return mCoords; }



private:

    PointerProperties mProperties;

    PointerCoords mCoords;

};



class MotionEventBuilder {

public:

    MotionEventBuilder(int32_t action, int32_t source) {

        mAction = action;

        mSource = source;

        mEventTime = systemTime(SYSTEM_TIME_MONOTONIC);

        mDownTime = mEventTime;

    }



    MotionEventBuilder& deviceId(int32_t deviceId) {

        mDeviceId = deviceId;

        return *this;

    }



    MotionEventBuilder& downTime(nsecs_t downTime) {

        mDownTime = downTime;

        return *this;

    }



    MotionEventBuilder& eventTime(nsecs_t eventTime) {

        mEventTime = eventTime;

        return *this;

    }



    MotionEventBuilder& displayId(int32_t displayId) {

        mDisplayId = displayId;

        return *this;

    }



    MotionEventBuilder& actionButton(int32_t actionButton) {

        mActionButton = actionButton;

        return *this;

    }



    MotionEventBuilder& buttonState(int32_t buttonState) {

        mButtonState = buttonState;

        return *this;

    }



    MotionEventBuilder& rawXCursorPosition(float rawXCursorPosition) {

        mRawXCursorPosition = rawXCursorPosition;

        return *this;

    }



    MotionEventBuilder& rawYCursorPosition(float rawYCursorPosition) {

        mRawYCursorPosition = rawYCursorPosition;

        return *this;

    }



    MotionEventBuilder& pointer(PointerBuilder pointer) {

        mPointers.push_back(pointer);

        return *this;

    }



    MotionEventBuilder& addFlag(uint32_t flags) {

        mFlags |= flags;

        return *this;

    }



    MotionEvent build() {

        std::vector<PointerProperties> pointerProperties;

        std::vector<PointerCoords> pointerCoords;

        for (const PointerBuilder& pointer : mPointers) {

            pointerProperties.push_back(pointer.buildProperties());

            pointerCoords.push_back(pointer.buildCoords());

        }



        // Set mouse cursor position for the most common cases to avoid boilerplate.

        if (mSource == AINPUT_SOURCE_MOUSE &&

            !MotionEvent::isValidCursorPosition(mRawXCursorPosition, mRawYCursorPosition)) {

            mRawXCursorPosition = pointerCoords[0].getX();

            mRawYCursorPosition = pointerCoords[0].getY();

        }



        MotionEvent event;

        ui::Transform identityTransform;

        event.initialize(InputEvent::nextId(), mDeviceId, mSource, mDisplayId, INVALID_HMAC,

                         mAction, mActionButton, mFlags, /* edgeFlags */ 0, AMETA_NONE,

                         mButtonState, MotionClassification::NONE, identityTransform,

                         /* xPrecision */ 0, /* yPrecision */ 0, mRawXCursorPosition,

                         mRawYCursorPosition, identityTransform, mDownTime, mEventTime,

                         mPointers.size(), pointerProperties.data(), pointerCoords.data());



        return event;

    }



private:

    int32_t mAction;

    int32_t mDeviceId = DEVICE_ID;

    int32_t mSource;

    nsecs_t mDownTime;

    nsecs_t mEventTime;

    int32_t mDisplayId{ADISPLAY_ID_DEFAULT};

    int32_t mActionButton{0};

    int32_t mButtonState{0};

    int32_t mFlags{0};

    float mRawXCursorPosition{AMOTION_EVENT_INVALID_CURSOR_POSITION};

    float mRawYCursorPosition{AMOTION_EVENT_INVALID_CURSOR_POSITION};



    std::vector<PointerBuilder> mPointers;

};



class MotionArgsBuilder {

public:

    MotionArgsBuilder(int32_t action, int32_t source) {

        mAction = action;

        mSource = source;

        mEventTime = systemTime(SYSTEM_TIME_MONOTONIC);

        mDownTime = mEventTime;

    }



    MotionArgsBuilder& deviceId(int32_t deviceId) {

        mDeviceId = deviceId;

        return *this;

    }



    MotionArgsBuilder& downTime(nsecs_t downTime) {

        mDownTime = downTime;

        return *this;

    }



    MotionArgsBuilder& eventTime(nsecs_t eventTime) {

        mEventTime = eventTime;

        return *this;

    }



    MotionArgsBuilder& displayId(int32_t displayId) {

        mDisplayId = displayId;

        return *this;

    }



    MotionArgsBuilder& policyFlags(int32_t policyFlags) {

        mPolicyFlags = policyFlags;

        return *this;

    }



    MotionArgsBuilder& actionButton(int32_t actionButton) {

        mActionButton = actionButton;

        return *this;

    }



    MotionArgsBuilder& buttonState(int32_t buttonState) {

        mButtonState = buttonState;

        return *this;

    }



    MotionArgsBuilder& rawXCursorPosition(float rawXCursorPosition) {

        mRawXCursorPosition = rawXCursorPosition;

        return *this;

    }



    MotionArgsBuilder& rawYCursorPosition(float rawYCursorPosition) {

        mRawYCursorPosition = rawYCursorPosition;

        return *this;

    }



    MotionArgsBuilder& pointer(PointerBuilder pointer) {

        mPointers.push_back(pointer);

        return *this;

    }



    MotionArgsBuilder& addFlag(uint32_t flags) {

        mFlags |= flags;

        return *this;

    }



    MotionArgsBuilder& classification(MotionClassification classification) {

        mClassification = classification;

        return *this;

    }



    NotifyMotionArgs build() {

        std::vector<PointerProperties> pointerProperties;

        std::vector<PointerCoords> pointerCoords;

        for (const PointerBuilder& pointer : mPointers) {

            pointerProperties.push_back(pointer.buildProperties());

            pointerCoords.push_back(pointer.buildCoords());

        }



        // Set mouse cursor position for the most common cases to avoid boilerplate.

        if (mSource == AINPUT_SOURCE_MOUSE &&

            !MotionEvent::isValidCursorPosition(mRawXCursorPosition, mRawYCursorPosition)) {

            mRawXCursorPosition = pointerCoords[0].getX();

            mRawYCursorPosition = pointerCoords[0].getY();

        }



        NotifyMotionArgs args(InputEvent::nextId(), mEventTime, /*readTime=*/mEventTime, mDeviceId,

                              mSource, mDisplayId, mPolicyFlags, mAction, mActionButton, mFlags,

                              AMETA_NONE, mButtonState, mClassification, /*edgeFlags=*/0,

                              mPointers.size(), pointerProperties.data(), pointerCoords.data(),

                              /*xPrecision=*/0, /*yPrecision=*/0, mRawXCursorPosition,

                              mRawYCursorPosition, mDownTime, /*videoFrames=*/{});



        return args;

    }



private:

    int32_t mAction;

    int32_t mDeviceId = DEVICE_ID;

    int32_t mSource;

    nsecs_t mDownTime;

    nsecs_t mEventTime;

    int32_t mDisplayId{ADISPLAY_ID_DEFAULT};

    int32_t mPolicyFlags = DEFAULT_POLICY_FLAGS;

    int32_t mActionButton{0};

    int32_t mButtonState{0};

    int32_t mFlags{0};

    MotionClassification mClassification{MotionClassification::NONE};

    float mRawXCursorPosition{AMOTION_EVENT_INVALID_CURSOR_POSITION};

    float mRawYCursorPosition{AMOTION_EVENT_INVALID_CURSOR_POSITION};



    std::vector<PointerBuilder> mPointers;

};



static InputEventInjectionResult injectMotionEvent(

        const std::unique_ptr<InputDispatcher>& dispatcher, const MotionEvent& event,

        std::chrono::milliseconds injectionTimeout = INJECT_EVENT_TIMEOUT,