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

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

Use enum class for EventEntry 

Switch EventEntry to use enum class. This improves type safety and
catches missing switch/case statements at compile time.

Bug: 70668286
Test: presubmit
Change-Id: Ib5f52cb357c87fcac8c7045ae13632814ab518b3
parent 5073d389

services/inputflinger/dispatcher/Entry.cpp

+5 −5
Original line number Diff line number Diff line
@@ -60,7 +60,7 @@ static std::string keyActionToString(int32_t action) { 


// --- EventEntry ---



EventEntry::EventEntry(uint32_t sequenceNum, int32_t type, nsecs_t eventTime, uint32_t policyFlags)

EventEntry::EventEntry(uint32_t sequenceNum, Type type, nsecs_t eventTime, uint32_t policyFlags)

      : sequenceNum(sequenceNum),

        refCount(1),

        type(type),
@@ -92,7 +92,7 @@ void EventEntry::releaseInjectionState() { 
// --- ConfigurationChangedEntry ---



ConfigurationChangedEntry::ConfigurationChangedEntry(uint32_t sequenceNum, nsecs_t eventTime)

      : EventEntry(sequenceNum, TYPE_CONFIGURATION_CHANGED, eventTime, 0) {}

      : EventEntry(sequenceNum, Type::CONFIGURATION_CHANGED, eventTime, 0) {}



ConfigurationChangedEntry::~ConfigurationChangedEntry() {}
@@ -103,7 +103,7 @@ void ConfigurationChangedEntry::appendDescription(std::string& msg) const { 
// --- DeviceResetEntry ---



DeviceResetEntry::DeviceResetEntry(uint32_t sequenceNum, nsecs_t eventTime, int32_t deviceId)

      : EventEntry(sequenceNum, TYPE_DEVICE_RESET, eventTime, 0), deviceId(deviceId) {}

      : EventEntry(sequenceNum, Type::DEVICE_RESET, eventTime, 0), deviceId(deviceId) {}



DeviceResetEntry::~DeviceResetEntry() {}
@@ -117,7 +117,7 @@ KeyEntry::KeyEntry(uint32_t sequenceNum, nsecs_t eventTime, int32_t deviceId, ui 
                   int32_t displayId, uint32_t policyFlags, int32_t action, int32_t flags,

                   int32_t keyCode, int32_t scanCode, int32_t metaState, int32_t repeatCount,

                   nsecs_t downTime)

      : EventEntry(sequenceNum, TYPE_KEY, eventTime, policyFlags),

      : EventEntry(sequenceNum, Type::KEY, eventTime, policyFlags),

        deviceId(deviceId),

        source(source),

        displayId(displayId),
@@ -165,7 +165,7 @@ MotionEntry::MotionEntry(uint32_t sequenceNum, nsecs_t eventTime, int32_t device 
                         float xCursorPosition, float yCursorPosition, nsecs_t downTime,

                         uint32_t pointerCount, const PointerProperties* pointerProperties,

                         const PointerCoords* pointerCoords, float xOffset, float yOffset)

      : EventEntry(sequenceNum, TYPE_MOTION, eventTime, policyFlags),

      : EventEntry(sequenceNum, Type::MOTION, eventTime, policyFlags),

        eventTime(eventTime),

        deviceId(deviceId),

        source(source),

services/inputflinger/dispatcher/Entry.h

+16 −3
Original line number Diff line number Diff line
@@ -33,11 +33,24 @@ namespace android::inputdispatcher { 
constexpr uint32_t SYNTHESIZED_EVENT_SEQUENCE_NUM = 0;



struct EventEntry {

    enum { TYPE_CONFIGURATION_CHANGED, TYPE_DEVICE_RESET, TYPE_KEY, TYPE_MOTION };

    enum class Type { CONFIGURATION_CHANGED, DEVICE_RESET, KEY, MOTION };



    static const char* typeToString(Type type) {

        switch (type) {

            case Type::CONFIGURATION_CHANGED:

                return "CONFIGURATION_CHANGED";

            case Type::DEVICE_RESET:

                return "DEVICE_RESET";

            case Type::KEY:

                return "KEY";

            case Type::MOTION:

                return "MOTION";

        }

    }



    uint32_t sequenceNum;

    mutable int32_t refCount;

    int32_t type;

    Type type;

    nsecs_t eventTime;

    uint32_t policyFlags;

    InjectionState* injectionState;
@@ -66,7 +79,7 @@ struct EventEntry { 
    virtual void appendDescription(std::string& msg) const = 0;



protected:

    EventEntry(uint32_t sequenceNum, int32_t type, nsecs_t eventTime, uint32_t policyFlags);

    EventEntry(uint32_t sequenceNum, Type type, nsecs_t eventTime, uint32_t policyFlags);

    virtual ~EventEntry();

    void releaseInjectionState();

};

services/inputflinger/dispatcher/InputDispatcher.cpp

+55 −28
Original line number Diff line number Diff line
@@ -386,7 +386,7 @@ void InputDispatcher::dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) { 
    }



    switch (mPendingEvent->type) {

        case EventEntry::TYPE_CONFIGURATION_CHANGED: {

        case EventEntry::Type::CONFIGURATION_CHANGED: {

            ConfigurationChangedEntry* typedEntry =

                    static_cast<ConfigurationChangedEntry*>(mPendingEvent);

            done = dispatchConfigurationChangedLocked(currentTime, typedEntry);
@@ -394,14 +394,14 @@ void InputDispatcher::dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) { 
            break;

        }



        case EventEntry::TYPE_DEVICE_RESET: {

        case EventEntry::Type::DEVICE_RESET: {

            DeviceResetEntry* typedEntry = static_cast<DeviceResetEntry*>(mPendingEvent);

            done = dispatchDeviceResetLocked(currentTime, typedEntry);

            dropReason = DropReason::NOT_DROPPED; // device resets are never dropped

            break;

        }



        case EventEntry::TYPE_KEY: {

        case EventEntry::Type::KEY: {

            KeyEntry* typedEntry = static_cast<KeyEntry*>(mPendingEvent);

            if (isAppSwitchDue) {

                if (isAppSwitchKeyEvent(*typedEntry)) {
@@ -421,7 +421,7 @@ void InputDispatcher::dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) { 
            break;

        }



        case EventEntry::TYPE_MOTION: {

        case EventEntry::Type::MOTION: {

            MotionEntry* typedEntry = static_cast<MotionEntry*>(mPendingEvent);

            if (dropReason == DropReason::NOT_DROPPED && isAppSwitchDue) {

                dropReason = DropReason::APP_SWITCH;
@@ -435,10 +435,6 @@ void InputDispatcher::dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) { 
            done = dispatchMotionLocked(currentTime, typedEntry, &dropReason, nextWakeupTime);

            break;

        }



        default:

            ALOG_ASSERT(false);

            break;

    }



    if (done) {
@@ -458,7 +454,7 @@ bool InputDispatcher::enqueueInboundEventLocked(EventEntry* entry) { 
    traceInboundQueueLengthLocked();



    switch (entry->type) {

        case EventEntry::TYPE_KEY: {

        case EventEntry::Type::KEY: {

            // Optimize app switch latency.

            // If the application takes too long to catch up then we drop all events preceding

            // the app switch key.
@@ -480,7 +476,7 @@ bool InputDispatcher::enqueueInboundEventLocked(EventEntry* entry) { 
            break;

        }



        case EventEntry::TYPE_MOTION: {

        case EventEntry::Type::MOTION: {

            // Optimize case where the current application is unresponsive and the user

            // decides to touch a window in a different application.

            // If the application takes too long to catch up then we drop all events preceding
@@ -508,6 +504,11 @@ bool InputDispatcher::enqueueInboundEventLocked(EventEntry* entry) { 
            }

            break;

        }

        case EventEntry::Type::CONFIGURATION_CHANGED:

        case EventEntry::Type::DEVICE_RESET: {

            // nothing to do

            break;

        }

    }



    return needWake;
@@ -627,12 +628,12 @@ void InputDispatcher::dropInboundEventLocked(const EventEntry& entry, DropReason 
    }



    switch (entry.type) {

        case EventEntry::TYPE_KEY: {

        case EventEntry::Type::KEY: {

            CancelationOptions options(CancelationOptions::CANCEL_NON_POINTER_EVENTS, reason);

            synthesizeCancelationEventsForAllConnectionsLocked(options);

            break;

        }

        case EventEntry::TYPE_MOTION: {

        case EventEntry::Type::MOTION: {

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

            if (motionEntry.source & AINPUT_SOURCE_CLASS_POINTER) {

                CancelationOptions options(CancelationOptions::CANCEL_POINTER_EVENTS, reason);
@@ -643,6 +644,11 @@ void InputDispatcher::dropInboundEventLocked(const EventEntry& entry, DropReason 
            }

            break;

        }

        case EventEntry::Type::CONFIGURATION_CHANGED:

        case EventEntry::Type::DEVICE_RESET: {

            LOG_ALWAYS_FATAL("Should not drop %s events", EventEntry::typeToString(entry.type));

            break;

        }

    }

}
@@ -1174,18 +1180,19 @@ void InputDispatcher::resetANRTimeoutsLocked() { 
int32_t InputDispatcher::getTargetDisplayId(const EventEntry& entry) {

    int32_t displayId;

    switch (entry.type) {

        case EventEntry::TYPE_KEY: {

        case EventEntry::Type::KEY: {

            const KeyEntry& keyEntry = static_cast<const KeyEntry&>(entry);

            displayId = keyEntry.displayId;

            break;

        }

        case EventEntry::TYPE_MOTION: {

        case EventEntry::Type::MOTION: {

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

            displayId = motionEntry.displayId;

            break;

        }

        default: {

            ALOGE("Unsupported event type '%" PRId32 "' for target display.", entry.type);

        case EventEntry::Type::CONFIGURATION_CHANGED:

        case EventEntry::Type::DEVICE_RESET: {

            ALOGE("%s events do not have a target display", EventEntry::typeToString(entry.type));

            return ADISPLAY_ID_NONE;

        }

    }
@@ -1849,7 +1856,7 @@ std::string InputDispatcher::checkWindowReadyForMoreInputLocked( 
    }



    // Ensure that the dispatch queues aren't too far backed up for this event.

    if (eventEntry.type == EventEntry::TYPE_KEY) {

    if (eventEntry.type == EventEntry::Type::KEY) {

        // If the event is a key event, then we must wait for all previous events to

        // complete before delivering it because previous events may have the

        // side-effect of transferring focus to a different window and we want to
@@ -1937,7 +1944,7 @@ void InputDispatcher::pokeUserActivityLocked(const EventEntry& eventEntry) { 


    int32_t eventType = USER_ACTIVITY_EVENT_OTHER;

    switch (eventEntry.type) {

        case EventEntry::TYPE_MOTION: {

        case EventEntry::Type::MOTION: {

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

            if (motionEntry.action == AMOTION_EVENT_ACTION_CANCEL) {

                return;
@@ -1948,7 +1955,7 @@ void InputDispatcher::pokeUserActivityLocked(const EventEntry& eventEntry) { 
            }

            break;

        }

        case EventEntry::TYPE_KEY: {

        case EventEntry::Type::KEY: {

            const KeyEntry& keyEntry = static_cast<const KeyEntry&>(eventEntry);

            if (keyEntry.flags & AKEY_EVENT_FLAG_CANCELED) {

                return;
@@ -1956,6 +1963,12 @@ void InputDispatcher::pokeUserActivityLocked(const EventEntry& eventEntry) { 
            eventType = USER_ACTIVITY_EVENT_BUTTON;

            break;

        }

        case EventEntry::Type::CONFIGURATION_CHANGED:

        case EventEntry::Type::DEVICE_RESET: {

            LOG_ALWAYS_FATAL("%s events are not user activity",

                             EventEntry::typeToString(eventEntry.type));

            break;

        }

    }



    std::unique_ptr<CommandEntry> commandEntry =
@@ -1996,7 +2009,7 @@ void InputDispatcher::prepareDispatchCycleLocked(nsecs_t currentTime, 


    // Split a motion event if needed.

    if (inputTarget->flags & InputTarget::FLAG_SPLIT) {

        ALOG_ASSERT(eventEntry->type == EventEntry::TYPE_MOTION);

        ALOG_ASSERT(eventEntry->type == EventEntry::Type::MOTION);



        const MotionEntry& originalMotionEntry = static_cast<const MotionEntry&>(*eventEntry);

        if (inputTarget->pointerIds.count() != originalMotionEntry.pointerCount) {
@@ -2080,7 +2093,7 @@ void InputDispatcher::enqueueDispatchEntryLocked(const sp<Connection>& connectio 


    // Apply target flags and update the connection's input state.

    switch (eventEntry->type) {

        case EventEntry::TYPE_KEY: {

        case EventEntry::Type::KEY: {

            const KeyEntry& keyEntry = static_cast<const KeyEntry&>(*eventEntry);

            dispatchEntry->resolvedAction = keyEntry.action;

            dispatchEntry->resolvedFlags = keyEntry.flags;
@@ -2097,7 +2110,7 @@ void InputDispatcher::enqueueDispatchEntryLocked(const sp<Connection>& connectio 
            break;

        }



        case EventEntry::TYPE_MOTION: {

        case EventEntry::Type::MOTION: {

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

            if (dispatchMode & InputTarget::FLAG_DISPATCH_AS_OUTSIDE) {

                dispatchEntry->resolvedAction = AMOTION_EVENT_ACTION_OUTSIDE;
@@ -2147,6 +2160,12 @@ void InputDispatcher::enqueueDispatchEntryLocked(const sp<Connection>& connectio 


            break;

        }

        case EventEntry::Type::CONFIGURATION_CHANGED:

        case EventEntry::Type::DEVICE_RESET: {

            LOG_ALWAYS_FATAL("%s events should not go to apps",

                             EventEntry::typeToString(eventEntry->type));

            break;

        }

    }



    // Remember that we are waiting for this dispatch to complete.
@@ -2206,7 +2225,7 @@ void InputDispatcher::startDispatchCycleLocked(nsecs_t currentTime, 
        status_t status;

        EventEntry* eventEntry = dispatchEntry->eventEntry;

        switch (eventEntry->type) {

            case EventEntry::TYPE_KEY: {

            case EventEntry::Type::KEY: {

                KeyEntry* keyEntry = static_cast<KeyEntry*>(eventEntry);



                // Publish the key event.
@@ -2221,7 +2240,7 @@ void InputDispatcher::startDispatchCycleLocked(nsecs_t currentTime, 
                break;

            }



            case EventEntry::TYPE_MOTION: {

            case EventEntry::Type::MOTION: {

                MotionEntry* motionEntry = static_cast<MotionEntry*>(eventEntry);



                PointerCoords scaledCoords[MAX_POINTERS];
@@ -2502,16 +2521,24 @@ void InputDispatcher::synthesizeCancelationEventsForConnectionLocked( 
        for (size_t i = 0; i < cancelationEvents.size(); i++) {

            EventEntry* cancelationEventEntry = cancelationEvents[i];

            switch (cancelationEventEntry->type) {

                case EventEntry::TYPE_KEY:

                case EventEntry::Type::KEY: {

                    logOutboundKeyDetails("cancel - ",

                                          static_cast<const KeyEntry&>(*cancelationEventEntry));

                    break;

                case EventEntry::TYPE_MOTION:

                }

                case EventEntry::Type::MOTION: {

                    logOutboundMotionDetails("cancel - ",

                                             static_cast<const MotionEntry&>(

                                                     *cancelationEventEntry));

                    break;

                }

                case EventEntry::Type::CONFIGURATION_CHANGED:

                case EventEntry::Type::DEVICE_RESET: {

                    LOG_ALWAYS_FATAL("%s event should not be found inside Connections's queue",

                                     EventEntry::typeToString(cancelationEventEntry->type));

                    break;

                }

            }



            InputTarget target;

            sp<InputWindowHandle> windowHandle =
@@ -4237,11 +4264,11 @@ void InputDispatcher::doDispatchCycleFinishedLockedInterruptible(CommandEntry* c 
    }



    bool restartEvent;

    if (dispatchEntry->eventEntry->type == EventEntry::TYPE_KEY) {

    if (dispatchEntry->eventEntry->type == EventEntry::Type::KEY) {

        KeyEntry* keyEntry = static_cast<KeyEntry*>(dispatchEntry->eventEntry);

        restartEvent =

                afterKeyEventLockedInterruptible(connection, dispatchEntry, keyEntry, handled);

    } else if (dispatchEntry->eventEntry->type == EventEntry::TYPE_MOTION) {

    } else if (dispatchEntry->eventEntry->type == EventEntry::Type::MOTION) {

        MotionEntry* motionEntry = static_cast<MotionEntry*>(dispatchEntry->eventEntry);

        restartEvent = afterMotionEventLockedInterruptible(connection, dispatchEntry, motionEntry,

                                                           handled);

services/inputflinger/reader/mapper/SwitchInputMapper.cpp

+2 −2
Original line number Diff line number Diff line
@@ -56,8 +56,8 @@ void SwitchInputMapper::processSwitch(int32_t switchCode, int32_t switchValue) { 
void SwitchInputMapper::sync(nsecs_t when) {

    if (mUpdatedSwitchMask) {

        uint32_t updatedSwitchValues = mSwitchValues & mUpdatedSwitchMask;

        NotifySwitchArgs args(mContext->getNextSequenceNum(), when, 0, updatedSwitchValues,

                              mUpdatedSwitchMask);

        NotifySwitchArgs args(mContext->getNextSequenceNum(), when, 0 /*policyFlags*/,

                              updatedSwitchValues, mUpdatedSwitchMask);

        getListener()->notifySwitch(&args);



        mUpdatedSwitchMask = 0;