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

Commit 2fe2ac3a authored by Siarhei Vishniakou's avatar Siarhei Vishniakou Committed by Automerger Merge Worker
Browse files

Merge "Convert input event type to enum class" into udc-dev am: ae55bae7 

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



Change-Id: I9f6f4acf2d299537e84fd67d8ed14b3033cec202
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 0c09dd14 ae55bae7

include/input/Input.h

+23 −8
Original line number Diff line number Diff line
@@ -210,7 +210,20 @@ vec2 transformWithoutTranslation(const ui::Transform& transform, const vec2& xy) 
 */

float transformAngle(const ui::Transform& transform, float angleRadians);



const char* inputEventTypeToString(int32_t type);

/**

 * The type of the InputEvent.

 * This should have 1:1 correspondence with the values of anonymous enum defined in input.h.

 */

enum class InputEventType {

    KEY = AINPUT_EVENT_TYPE_KEY,

    MOTION = AINPUT_EVENT_TYPE_MOTION,

    FOCUS = AINPUT_EVENT_TYPE_FOCUS,

    CAPTURE = AINPUT_EVENT_TYPE_CAPTURE,

    DRAG = AINPUT_EVENT_TYPE_DRAG,

    TOUCH_MODE = AINPUT_EVENT_TYPE_TOUCH_MODE,

    ftl_first = KEY,

    ftl_last = TOUCH_MODE,

};



std::string inputEventSourceToString(int32_t source);
@@ -482,7 +495,7 @@ class InputEvent : public AInputEvent { 
public:

    virtual ~InputEvent() { }



    virtual int32_t getType() const = 0;

    virtual InputEventType getType() const = 0;



    inline int32_t getId() const { return mId; }
@@ -513,6 +526,8 @@ protected: 
    std::array<uint8_t, 32> mHmac;

};



std::ostream& operator<<(std::ostream& out, const InputEvent& event);



/*

 * Key events.

 */
@@ -520,7 +535,7 @@ class KeyEvent : public InputEvent { 
public:

    virtual ~KeyEvent() { }



    virtual int32_t getType() const { return AINPUT_EVENT_TYPE_KEY; }

    virtual InputEventType getType() const { return InputEventType::KEY; }



    inline int32_t getAction() const { return mAction; }
@@ -571,7 +586,7 @@ class MotionEvent : public InputEvent { 
public:

    virtual ~MotionEvent() { }



    virtual int32_t getType() const { return AINPUT_EVENT_TYPE_MOTION; }

    virtual InputEventType getType() const { return InputEventType::MOTION; }



    inline int32_t getAction() const { return mAction; }
@@ -899,7 +914,7 @@ class FocusEvent : public InputEvent { 
public:

    virtual ~FocusEvent() {}



    virtual int32_t getType() const override { return AINPUT_EVENT_TYPE_FOCUS; }

    virtual InputEventType getType() const override { return InputEventType::FOCUS; }



    inline bool getHasFocus() const { return mHasFocus; }
@@ -918,7 +933,7 @@ class CaptureEvent : public InputEvent { 
public:

    virtual ~CaptureEvent() {}



    virtual int32_t getType() const override { return AINPUT_EVENT_TYPE_CAPTURE; }

    virtual InputEventType getType() const override { return InputEventType::CAPTURE; }



    inline bool getPointerCaptureEnabled() const { return mPointerCaptureEnabled; }
@@ -937,7 +952,7 @@ class DragEvent : public InputEvent { 
public:

    virtual ~DragEvent() {}



    virtual int32_t getType() const override { return AINPUT_EVENT_TYPE_DRAG; }

    virtual InputEventType getType() const override { return InputEventType::DRAG; }



    inline bool isExiting() const { return mIsExiting; }
@@ -961,7 +976,7 @@ class TouchModeEvent : public InputEvent { 
public:

    virtual ~TouchModeEvent() {}



    virtual int32_t getType() const override { return AINPUT_EVENT_TYPE_TOUCH_MODE; }

    virtual InputEventType getType() const override { return InputEventType::TOUCH_MODE; }



    inline bool isInTouchMode() const { return mIsInTouchMode; }

libs/gui/tests/EndToEndNativeInputTest.cpp

+9 −9
Original line number Diff line number Diff line
@@ -164,7 +164,7 @@ public: 
    void assertFocusChange(bool hasFocus) {

        InputEvent *ev = consumeEvent();

        ASSERT_NE(ev, nullptr);

        ASSERT_EQ(AINPUT_EVENT_TYPE_FOCUS, ev->getType());

        ASSERT_EQ(InputEventType::FOCUS, ev->getType());

        FocusEvent *focusEvent = static_cast<FocusEvent *>(ev);

        EXPECT_EQ(hasFocus, focusEvent->getHasFocus());

    }
@@ -172,7 +172,7 @@ public: 
    void expectTap(int x, int y) {

        InputEvent* ev = consumeEvent();

        ASSERT_NE(ev, nullptr);

        ASSERT_EQ(AINPUT_EVENT_TYPE_MOTION, ev->getType());

        ASSERT_EQ(InputEventType::MOTION, ev->getType());

        MotionEvent* mev = static_cast<MotionEvent*>(ev);

        EXPECT_EQ(AMOTION_EVENT_ACTION_DOWN, mev->getAction());

        EXPECT_EQ(x, mev->getX(0));
@@ -181,7 +181,7 @@ public: 


        ev = consumeEvent();

        ASSERT_NE(ev, nullptr);

        ASSERT_EQ(AINPUT_EVENT_TYPE_MOTION, ev->getType());

        ASSERT_EQ(InputEventType::MOTION, ev->getType());

        mev = static_cast<MotionEvent*>(ev);

        EXPECT_EQ(AMOTION_EVENT_ACTION_UP, mev->getAction());

        EXPECT_EQ(0, mev->getFlags() & VERIFIED_MOTION_EVENT_FLAGS);
@@ -190,7 +190,7 @@ public: 
    void expectTapWithFlag(int x, int y, int32_t flags) {

        InputEvent *ev = consumeEvent();

        ASSERT_NE(ev, nullptr);

        ASSERT_EQ(AINPUT_EVENT_TYPE_MOTION, ev->getType());

        ASSERT_EQ(InputEventType::MOTION, ev->getType());

        MotionEvent *mev = static_cast<MotionEvent *>(ev);

        EXPECT_EQ(AMOTION_EVENT_ACTION_DOWN, mev->getAction());

        EXPECT_EQ(x, mev->getX(0));
@@ -199,7 +199,7 @@ public: 


        ev = consumeEvent();

        ASSERT_NE(ev, nullptr);

        ASSERT_EQ(AINPUT_EVENT_TYPE_MOTION, ev->getType());

        ASSERT_EQ(InputEventType::MOTION, ev->getType());

        mev = static_cast<MotionEvent *>(ev);

        EXPECT_EQ(AMOTION_EVENT_ACTION_UP, mev->getAction());

        EXPECT_EQ(flags, mev->getFlags() & flags);
@@ -208,7 +208,7 @@ public: 
    void expectTapInDisplayCoordinates(int displayX, int displayY) {

        InputEvent *ev = consumeEvent();

        ASSERT_NE(ev, nullptr);

        ASSERT_EQ(AINPUT_EVENT_TYPE_MOTION, ev->getType());

        ASSERT_EQ(InputEventType::MOTION, ev->getType());

        MotionEvent *mev = static_cast<MotionEvent *>(ev);

        EXPECT_EQ(AMOTION_EVENT_ACTION_DOWN, mev->getAction());

        const PointerCoords &coords = *mev->getRawPointerCoords(0 /*pointerIndex*/);
@@ -218,7 +218,7 @@ public: 


        ev = consumeEvent();

        ASSERT_NE(ev, nullptr);

        ASSERT_EQ(AINPUT_EVENT_TYPE_MOTION, ev->getType());

        ASSERT_EQ(InputEventType::MOTION, ev->getType());

        mev = static_cast<MotionEvent *>(ev);

        EXPECT_EQ(AMOTION_EVENT_ACTION_UP, mev->getAction());

        EXPECT_EQ(0, mev->getFlags() & VERIFIED_MOTION_EVENT_FLAGS);
@@ -227,7 +227,7 @@ public: 
    void expectKey(uint32_t keycode) {

        InputEvent *ev = consumeEvent();

        ASSERT_NE(ev, nullptr);

        ASSERT_EQ(AINPUT_EVENT_TYPE_KEY, ev->getType());

        ASSERT_EQ(InputEventType::KEY, ev->getType());

        KeyEvent *keyEvent = static_cast<KeyEvent *>(ev);

        EXPECT_EQ(AMOTION_EVENT_ACTION_DOWN, keyEvent->getAction());

        EXPECT_EQ(keycode, keyEvent->getKeyCode());
@@ -235,7 +235,7 @@ public: 


        ev = consumeEvent();

        ASSERT_NE(ev, nullptr);

        ASSERT_EQ(AINPUT_EVENT_TYPE_KEY, ev->getType());

        ASSERT_EQ(InputEventType::KEY, ev->getType());

        keyEvent = static_cast<KeyEvent *>(ev);

        EXPECT_EQ(AMOTION_EVENT_ACTION_UP, keyEvent->getAction());

        EXPECT_EQ(keycode, keyEvent->getKeyCode());

libs/input/Input.cpp

+70 −56
Original line number Diff line number Diff line
@@ -170,30 +170,6 @@ float transformAngle(const ui::Transform& transform, float angleRadians) { 
    return atan2f(transformedPoint.x, -transformedPoint.y);

}



const char* inputEventTypeToString(int32_t type) {

    switch (type) {

        case AINPUT_EVENT_TYPE_KEY: {

            return "KEY";

        }

        case AINPUT_EVENT_TYPE_MOTION: {

            return "MOTION";

        }

        case AINPUT_EVENT_TYPE_FOCUS: {

            return "FOCUS";

        }

        case AINPUT_EVENT_TYPE_CAPTURE: {

            return "CAPTURE";

        }

        case AINPUT_EVENT_TYPE_DRAG: {

            return "DRAG";

        }

        case AINPUT_EVENT_TYPE_TOUCH_MODE: {

            return "TOUCH_MODE";

        }

    }

    return "UNKNOWN";

}



std::string inputEventSourceToString(int32_t source) {

    if (source == AINPUT_SOURCE_UNKNOWN) {

        return "UNKNOWN";
@@ -287,6 +263,37 @@ int32_t InputEvent::nextId() { 
    return idGen.nextId();

}



std::ostream& operator<<(std::ostream& out, const InputEvent& event) {

    switch (event.getType()) {

        case InputEventType::KEY: {

            const KeyEvent& keyEvent = static_cast<const KeyEvent&>(event);

            out << keyEvent;

            return out;

        }

        case InputEventType::MOTION: {

            const MotionEvent& motionEvent = static_cast<const MotionEvent&>(event);

            out << motionEvent;

            return out;

        }

        case InputEventType::FOCUS: {

            out << "FocusEvent";

            return out;

        }

        case InputEventType::CAPTURE: {

            out << "CaptureEvent";

            return out;

        }

        case InputEventType::DRAG: {

            out << "DragEvent";

            return out;

        }

        case InputEventType::TOUCH_MODE: {

            out << "TouchModeEvent";

            return out;

        }

    }

}



// --- KeyEvent ---



const char* KeyEvent::getLabel(int32_t keyCode) {
@@ -1165,38 +1172,44 @@ TouchModeEvent* PooledInputEventFactory::createTouchModeEvent() { 


void PooledInputEventFactory::recycle(InputEvent* event) {

    switch (event->getType()) {

    case AINPUT_EVENT_TYPE_KEY:

        case InputEventType::KEY: {

            if (mKeyEventPool.size() < mMaxPoolSize) {

                mKeyEventPool.push(std::unique_ptr<KeyEvent>(static_cast<KeyEvent*>(event)));

                return;

            }

            break;

    case AINPUT_EVENT_TYPE_MOTION:

        }

        case InputEventType::MOTION: {

            if (mMotionEventPool.size() < mMaxPoolSize) {

            mMotionEventPool.push(std::unique_ptr<MotionEvent>(static_cast<MotionEvent*>(event)));

                mMotionEventPool.push(

                        std::unique_ptr<MotionEvent>(static_cast<MotionEvent*>(event)));

                return;

            }

            break;

    case AINPUT_EVENT_TYPE_FOCUS:

        }

        case InputEventType::FOCUS: {

            if (mFocusEventPool.size() < mMaxPoolSize) {

                mFocusEventPool.push(std::unique_ptr<FocusEvent>(static_cast<FocusEvent*>(event)));

                return;

            }

            break;

    case AINPUT_EVENT_TYPE_CAPTURE:

        }

        case InputEventType::CAPTURE: {

            if (mCaptureEventPool.size() < mMaxPoolSize) {

                mCaptureEventPool.push(

                        std::unique_ptr<CaptureEvent>(static_cast<CaptureEvent*>(event)));

                return;

            }

            break;

    case AINPUT_EVENT_TYPE_DRAG:

        }

        case InputEventType::DRAG: {

            if (mDragEventPool.size() < mMaxPoolSize) {

                mDragEventPool.push(std::unique_ptr<DragEvent>(static_cast<DragEvent*>(event)));

                return;

            }

            break;

    case AINPUT_EVENT_TYPE_TOUCH_MODE:

        }

        case InputEventType::TOUCH_MODE: {

            if (mTouchModeEventPool.size() < mMaxPoolSize) {

                mTouchModeEventPool.push(

                        std::unique_ptr<TouchModeEvent>(static_cast<TouchModeEvent*>(event)));
@@ -1204,6 +1217,7 @@ void PooledInputEventFactory::recycle(InputEvent* event) { 
            }

            break;

        }

    }

    delete event;

}

libs/input/android/os/InputEventInjectionSync.aidl

+3 −0
Original line number Diff line number Diff line
@@ -33,4 +33,7 @@ enum InputEventInjectionSync { 


    /* Waits for the input event to be completely processed. */

    WAIT_FOR_FINISHED = 2,



    ftl_first = NONE,

    ftl_last = WAIT_FOR_FINISHED,

}

libs/input/tests/InputEvent_test.cpp

+2 −2
Original line number Diff line number Diff line
@@ -197,7 +197,7 @@ TEST_F(KeyEventTest, Properties) { 
                     ARBITRARY_DOWN_TIME, ARBITRARY_EVENT_TIME);



    ASSERT_EQ(id, event.getId());

    ASSERT_EQ(AINPUT_EVENT_TYPE_KEY, event.getType());

    ASSERT_EQ(InputEventType::KEY, event.getType());

    ASSERT_EQ(2, event.getDeviceId());

    ASSERT_EQ(AINPUT_SOURCE_GAMEPAD, event.getSource());

    ASSERT_EQ(DISPLAY_ID, event.getDisplayId());
@@ -346,7 +346,7 @@ void MotionEventTest::initializeEventWithHistory(MotionEvent* event) { 
void MotionEventTest::assertEqualsEventWithHistory(const MotionEvent* event) {

    // Check properties.

    ASSERT_EQ(mId, event->getId());

    ASSERT_EQ(AINPUT_EVENT_TYPE_MOTION, event->getType());

    ASSERT_EQ(InputEventType::MOTION, event->getType());

    ASSERT_EQ(2, event->getDeviceId());

    ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, event->getSource());

    ASSERT_EQ(DISPLAY_ID, event->getDisplayId());