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

Commit 74c3d78f authored by Michael Wright's avatar Michael Wright Committed by Android (Google) Code Review
Browse files

Merge changes I4fdbdad3,Ied8edcab,I360c4318 

* changes:
  Convert KeyEntry::InterceptKeyResult to enum class.
  Convert CancelationOptions::Mode to an enum class.
  Fix for-loop type in dumpDispatchStateLocked
parents eddd157f 5caf55a9

services/inputflinger/dispatcher/CancelationOptions.h

+1 −1
Original line number Diff line number Diff line
@@ -24,7 +24,7 @@ namespace inputdispatcher { 


/* Specifies which events are to be canceled and why. */

struct CancelationOptions {

    enum Mode {

    enum class Mode {

        CANCEL_ALL_EVENTS = 0,

        CANCEL_POINTER_EVENTS = 1,

        CANCEL_NON_POINTER_EVENTS = 2,

services/inputflinger/dispatcher/Entry.cpp

+2 −2
Original line number Diff line number Diff line
@@ -166,7 +166,7 @@ KeyEntry::KeyEntry(int32_t id, nsecs_t eventTime, int32_t deviceId, uint32_t sou 
        repeatCount(repeatCount),

        downTime(downTime),

        syntheticRepeat(false),

        interceptKeyResult(KeyEntry::INTERCEPT_KEY_RESULT_UNKNOWN),

        interceptKeyResult(KeyEntry::InterceptKeyResult::UNKNOWN),

        interceptKeyWakeupTime(0) {}



KeyEntry::~KeyEntry() {}
@@ -189,7 +189,7 @@ void KeyEntry::recycle() { 


    dispatchInProgress = false;

    syntheticRepeat = false;

    interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_UNKNOWN;

    interceptKeyResult = KeyEntry::InterceptKeyResult::UNKNOWN;

    interceptKeyWakeupTime = 0;

}

services/inputflinger/dispatcher/Entry.h

+5 −5
Original line number Diff line number Diff line
@@ -140,11 +140,11 @@ struct KeyEntry : EventEntry { 


    bool syntheticRepeat; // set to true for synthetic key repeats



    enum InterceptKeyResult {

        INTERCEPT_KEY_RESULT_UNKNOWN,

        INTERCEPT_KEY_RESULT_SKIP,

        INTERCEPT_KEY_RESULT_CONTINUE,

        INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER,

    enum class InterceptKeyResult {

        UNKNOWN,

        SKIP,

        CONTINUE,

        TRY_AGAIN_LATER,

    };

    InterceptKeyResult interceptKeyResult; // set based on the interception result

    nsecs_t interceptKeyWakeupTime;        // used with INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER

services/inputflinger/dispatcher/InputDispatcher.cpp

+31 −33
Original line number Diff line number Diff line
@@ -60,7 +60,6 @@ using android::gui::FocusRequest; 
using android::gui::TouchOcclusionMode;

using android::gui::WindowInfo;

using android::gui::WindowInfoHandle;

using android::os::IInputConstants;

using android::os::InputEventInjectionResult;

using android::os::InputEventInjectionSync;
@@ -1033,8 +1032,8 @@ bool InputDispatcher::enqueueInboundEventLocked(std::unique_ptr<EventEntry> newE 
                KeyEntry& pendingKey = static_cast<KeyEntry&>(*mPendingEvent);

                if (pendingKey.keyCode == keyEntry.keyCode &&

                    pendingKey.interceptKeyResult ==

                            KeyEntry::INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER) {

                    pendingKey.interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_UNKNOWN;

                            KeyEntry::InterceptKeyResult::TRY_AGAIN_LATER) {

                    pendingKey.interceptKeyResult = KeyEntry::InterceptKeyResult::UNKNOWN;

                    pendingKey.interceptKeyWakeupTime = 0;

                    needWake = true;

                }
@@ -1169,17 +1168,18 @@ void InputDispatcher::dropInboundEventLocked(const EventEntry& entry, DropReason 


    switch (entry.type) {

        case EventEntry::Type::KEY: {

            CancelationOptions options(CancelationOptions::CANCEL_NON_POINTER_EVENTS, reason);

            CancelationOptions options(CancelationOptions::Mode::CANCEL_NON_POINTER_EVENTS, reason);

            synthesizeCancelationEventsForAllConnectionsLocked(options);

            break;

        }

        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);

                CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS, reason);

                synthesizeCancelationEventsForAllConnectionsLocked(options);

            } else {

                CancelationOptions options(CancelationOptions::CANCEL_NON_POINTER_EVENTS, reason);

                CancelationOptions options(CancelationOptions::Mode::CANCEL_NON_POINTER_EVENTS,

                                           reason);

                synthesizeCancelationEventsForAllConnectionsLocked(options);

            }

            break;
@@ -1334,7 +1334,7 @@ bool InputDispatcher::dispatchDeviceResetLocked(nsecs_t currentTime, 
        resetKeyRepeatLocked();

    }



    CancelationOptions options(CancelationOptions::CANCEL_ALL_EVENTS, "device was reset");

    CancelationOptions options(CancelationOptions::Mode::CANCEL_ALL_EVENTS, "device was reset");

    options.deviceId = entry.deviceId;

    synthesizeCancelationEventsForAllConnectionsLocked(options);

    return true;
@@ -1539,19 +1539,19 @@ bool InputDispatcher::dispatchKeyLocked(nsecs_t currentTime, std::shared_ptr<Key 
    }



    // Handle case where the policy asked us to try again later last time.

    if (entry->interceptKeyResult == KeyEntry::INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER) {

    if (entry->interceptKeyResult == KeyEntry::InterceptKeyResult::TRY_AGAIN_LATER) {

        if (currentTime < entry->interceptKeyWakeupTime) {

            if (entry->interceptKeyWakeupTime < *nextWakeupTime) {

                *nextWakeupTime = entry->interceptKeyWakeupTime;

            }

            return false; // wait until next wakeup

        }

        entry->interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_UNKNOWN;

        entry->interceptKeyResult = KeyEntry::InterceptKeyResult::UNKNOWN;

        entry->interceptKeyWakeupTime = 0;

    }



    // Give the policy a chance to intercept the key.

    if (entry->interceptKeyResult == KeyEntry::INTERCEPT_KEY_RESULT_UNKNOWN) {

    if (entry->interceptKeyResult == KeyEntry::InterceptKeyResult::UNKNOWN) {

        if (entry->policyFlags & POLICY_FLAG_PASS_TO_USER) {

            sp<IBinder> focusedWindowToken =

                    mFocusResolver.getFocusedWindowToken(getTargetDisplayId(*entry));
@@ -1562,9 +1562,9 @@ bool InputDispatcher::dispatchKeyLocked(nsecs_t currentTime, std::shared_ptr<Key 
            postCommandLocked(std::move(command));

            return false; // wait for the command to run

        } else {

            entry->interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_CONTINUE;

            entry->interceptKeyResult = KeyEntry::InterceptKeyResult::CONTINUE;

        }

    } else if (entry->interceptKeyResult == KeyEntry::INTERCEPT_KEY_RESULT_SKIP) {

    } else if (entry->interceptKeyResult == KeyEntry::InterceptKeyResult::SKIP) {

        if (*dropReason == DropReason::NOT_DROPPED) {

            *dropReason = DropReason::POLICY;

        }
@@ -1723,9 +1723,9 @@ bool InputDispatcher::dispatchMotionLocked(nsecs_t currentTime, std::shared_ptr< 
        return true;

    }

    if (injectionResult != InputEventInjectionResult::SUCCEEDED) {

        CancelationOptions::Mode mode(isPointerEvent

                                              ? CancelationOptions::CANCEL_POINTER_EVENTS

                                              : CancelationOptions::CANCEL_NON_POINTER_EVENTS);

        CancelationOptions::Mode mode(

                isPointerEvent ? CancelationOptions::Mode::CANCEL_POINTER_EVENTS

                               : CancelationOptions::Mode::CANCEL_NON_POINTER_EVENTS);

        CancelationOptions options(mode, "input event injection failed");

        synthesizeCancelationEventsForMonitorsLocked(options);

        return true;
@@ -1736,7 +1736,7 @@ bool InputDispatcher::dispatchMotionLocked(nsecs_t currentTime, std::shared_ptr< 


    // Dispatch the motion.

    if (conflictingPointerActions) {

        CancelationOptions options(CancelationOptions::CANCEL_POINTER_EVENTS,

        CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS,

                                   "conflicting pointer actions");

        synthesizeCancelationEventsForAllConnectionsLocked(options);

    }
@@ -1837,7 +1837,7 @@ void InputDispatcher::cancelEventsForAnrLocked(const sp<Connection>& connection) 
    ALOGW("Canceling events for %s because it is unresponsive",

          connection->inputChannel->getName().c_str());

    if (connection->status == Connection::Status::NORMAL) {

        CancelationOptions options(CancelationOptions::CANCEL_ALL_EVENTS,

        CancelationOptions options(CancelationOptions::Mode::CANCEL_ALL_EVENTS,

                                   "application not responding");

        synthesizeCancelationEventsForConnectionLocked(connection, options);

    }
@@ -4831,7 +4831,7 @@ void InputDispatcher::setInputWindowsLocked( 
                std::shared_ptr<InputChannel> touchedInputChannel =

                        getInputChannelLocked(touchedWindow.windowHandle->getToken());

                if (touchedInputChannel != nullptr) {

                    CancelationOptions options(CancelationOptions::CANCEL_POINTER_EVENTS,

                    CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS,

                                               "touched window was removed");

                    synthesizeCancelationEventsForInputChannelLocked(touchedInputChannel, options);

                    // Since we are about to drop the touch, cancel the events for the wallpaper as
@@ -4877,7 +4877,7 @@ void InputDispatcher::setInputWindowsLocked( 
            std::shared_ptr<InputChannel> inputChannel =

                    getInputChannelLocked(newWindowHandle->getToken());

            if (inputChannel != nullptr) {

                CancelationOptions options(CancelationOptions::CANCEL_POINTER_EVENTS,

                CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS,

                                           "touched window's orientation changed");

                synthesizeCancelationEventsForInputChannelLocked(inputChannel, options);

            }
@@ -4958,7 +4958,7 @@ void InputDispatcher::setFocusedDisplay(int32_t displayId) { 
                        getInputChannelLocked(oldFocusedWindowToken);

                if (inputChannel != nullptr) {

                    CancelationOptions

                            options(CancelationOptions::CANCEL_NON_POINTER_EVENTS,

                            options(CancelationOptions::Mode::CANCEL_NON_POINTER_EVENTS,

                                    "The display which contains this window no longer has focus.");

                    options.displayId = ADISPLAY_ID_NONE;

                    synthesizeCancelationEventsForInputChannelLocked(inputChannel, options);
@@ -5185,7 +5185,7 @@ bool InputDispatcher::transferTouchFocus(const sp<IBinder>& fromToken, const sp< 
        if (fromConnection != nullptr && toConnection != nullptr) {

            fromConnection->inputState.mergePointerStateTo(toConnection->inputState);

            CancelationOptions

                    options(CancelationOptions::CANCEL_POINTER_EVENTS,

                    options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS,

                            "transferring touch focus from this window to another window");

            synthesizeCancelationEventsForConnectionLocked(fromConnection, options);

            synthesizePointerDownEventsForConnectionLocked(downTimeInTarget, toConnection);
@@ -5259,7 +5259,7 @@ void InputDispatcher::resetAndDropEverythingLocked(const char* reason) { 
        ALOGD("Resetting and dropping all events (%s).", reason);

    }



    CancelationOptions options(CancelationOptions::CANCEL_ALL_EVENTS, reason);

    CancelationOptions options(CancelationOptions::Mode::CANCEL_ALL_EVENTS, reason);

    synthesizeCancelationEventsForAllConnectionsLocked(options);



    resetKeyRepeatLocked();
@@ -5440,9 +5440,7 @@ void InputDispatcher::dumpDispatchStateLocked(std::string& dump) { 


    if (!mReplacedKeys.empty()) {

        dump += INDENT "ReplacedKeys:\n";

        for (const std::pair<KeyReplacement, int32_t>& pair : mReplacedKeys) {

            const KeyReplacement& replacement = pair.first;

            int32_t newKeyCode = pair.second;

        for (const auto& [replacement, newKeyCode] : mReplacedKeys) {

            dump += StringPrintf(INDENT2 "originalKeyCode=%d, deviceId=%d -> newKeyCode=%d\n",

                                 replacement.keyCode, replacement.deviceId, newKeyCode);

        }
@@ -5686,7 +5684,7 @@ status_t InputDispatcher::pilferPointersLocked(const sp<IBinder>& token) { 
    TouchState& state = *statePtr;

    TouchedWindow& window = *windowPtr;

    // Send cancel events to all the input channels we're stealing from.

    CancelationOptions options(CancelationOptions::CANCEL_POINTER_EVENTS,

    CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS,

                               "input channel stole pointer stream");

    options.deviceId = state.deviceId;

    options.displayId = displayId;
@@ -5972,11 +5970,11 @@ void InputDispatcher::doInterceptKeyBeforeDispatchingCommand(const sp<IBinder>& 
    } // acquire lock



    if (delay < 0) {

        entry.interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_SKIP;

        entry.interceptKeyResult = KeyEntry::InterceptKeyResult::SKIP;

    } else if (delay == 0) {

        entry.interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_CONTINUE;

        entry.interceptKeyResult = KeyEntry::InterceptKeyResult::CONTINUE;

    } else {

        entry.interceptKeyResult = KeyEntry::INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER;

        entry.interceptKeyResult = KeyEntry::InterceptKeyResult::TRY_AGAIN_LATER;

        entry.interceptKeyWakeupTime = now() + delay;

    }

}
@@ -6086,7 +6084,7 @@ bool InputDispatcher::afterKeyEventLockedInterruptable(const sp<Connection>& con 


            // Cancel the fallback key.

            if (fallbackKeyCode != AKEYCODE_UNKNOWN) {

                CancelationOptions options(CancelationOptions::CANCEL_FALLBACK_EVENTS,

                CancelationOptions options(CancelationOptions::Mode::CANCEL_FALLBACK_EVENTS,

                                           "application handled the original non-fallback key "

                                           "or is no longer a foreground target, "

                                           "canceling previously dispatched fallback key");
@@ -6163,7 +6161,7 @@ bool InputDispatcher::afterKeyEventLockedInterruptable(const sp<Connection>& con 
                }

            }



            CancelationOptions options(CancelationOptions::CANCEL_FALLBACK_EVENTS,

            CancelationOptions options(CancelationOptions::Mode::CANCEL_FALLBACK_EVENTS,

                                       "canceling fallback, policy no longer desires it");

            options.keyCode = fallbackKeyCode;

            synthesizeCancelationEventsForConnectionLocked(connection, options);
@@ -6316,7 +6314,7 @@ void InputDispatcher::onFocusChangedLocked(const FocusResolver::FocusChanges& ch 
    if (changes.oldFocus) {

        std::shared_ptr<InputChannel> focusedInputChannel = getInputChannelLocked(changes.oldFocus);

        if (focusedInputChannel) {

            CancelationOptions options(CancelationOptions::CANCEL_NON_POINTER_EVENTS,

            CancelationOptions options(CancelationOptions::Mode::CANCEL_NON_POINTER_EVENTS,

                                       "focus left window");

            synthesizeCancelationEventsForInputChannelLocked(focusedInputChannel, options);

            enqueueFocusEventLocked(changes.oldFocus, false /*hasFocus*/, changes.reason);
@@ -6456,7 +6454,7 @@ void InputDispatcher::cancelCurrentTouch() { 
    {

        std::scoped_lock _l(mLock);

        ALOGD("Canceling all ongoing pointer gestures on all displays.");

        CancelationOptions options(CancelationOptions::CANCEL_POINTER_EVENTS,

        CancelationOptions options(CancelationOptions::Mode::CANCEL_POINTER_EVENTS,

                                   "cancel current touch");

        synthesizeCancelationEventsForAllConnectionsLocked(options);

services/inputflinger/dispatcher/InputState.cpp

+6 −6
Original line number Diff line number Diff line
@@ -500,10 +500,10 @@ bool InputState::shouldCancelKey(const KeyMemento& memento, const CancelationOpt 
    }



    switch (options.mode) {

        case CancelationOptions::CANCEL_ALL_EVENTS:

        case CancelationOptions::CANCEL_NON_POINTER_EVENTS:

        case CancelationOptions::Mode::CANCEL_ALL_EVENTS:

        case CancelationOptions::Mode::CANCEL_NON_POINTER_EVENTS:

            return true;

        case CancelationOptions::CANCEL_FALLBACK_EVENTS:

        case CancelationOptions::Mode::CANCEL_FALLBACK_EVENTS:

            return memento.flags & AKEY_EVENT_FLAG_FALLBACK;

        default:

            return false;
@@ -521,11 +521,11 @@ bool InputState::shouldCancelMotion(const MotionMemento& memento, 
    }



    switch (options.mode) {

        case CancelationOptions::CANCEL_ALL_EVENTS:

        case CancelationOptions::Mode::CANCEL_ALL_EVENTS:

            return true;

        case CancelationOptions::CANCEL_POINTER_EVENTS:

        case CancelationOptions::Mode::CANCEL_POINTER_EVENTS:

            return memento.source & AINPUT_SOURCE_CLASS_POINTER;

        case CancelationOptions::CANCEL_NON_POINTER_EVENTS:

        case CancelationOptions::Mode::CANCEL_NON_POINTER_EVENTS:

            return !(memento.source & AINPUT_SOURCE_CLASS_POINTER);

        default:

            return false;