diff options
| -rw-r--r-- | services/inputflinger/Android.bp | 56 | ||||
| -rw-r--r-- | services/inputflinger/BlockingQueue.h | 25 | ||||
| -rw-r--r-- | services/inputflinger/InputClassifier.h | 9 | ||||
| -rw-r--r-- | services/inputflinger/InputDispatcher.cpp | 79 | ||||
| -rw-r--r-- | services/inputflinger/InputDispatcher.h | 228 |
5 files changed, 197 insertions, 200 deletions
diff --git a/services/inputflinger/Android.bp b/services/inputflinger/Android.bp index f73d498bb2..63e759c0f8 100644 --- a/services/inputflinger/Android.bp +++ b/services/inputflinger/Android.bp @@ -12,8 +12,20 @@ // See the License for the specific language governing permissions and // limitations under the License. +cc_defaults { + name: "inputflinger_defaults", + cflags: [ + "-Wall", + "-Wextra", + "-Werror", + "-Wno-unused-parameter", + "-Wthread-safety", + ], +} + cc_library_shared { name: "libinputflinger", + defaults: ["inputflinger_defaults"], srcs: [ "InputClassifier.cpp", @@ -23,10 +35,10 @@ cc_library_shared { shared_libs: [ "android.hardware.input.classifier@1.0", + "libbase", "libinputflinger_base", "libinputreporter", "libinputreader", - "libbase", "libbinder", "libcutils", "libhidlbase", @@ -38,12 +50,6 @@ cc_library_shared { ], cflags: [ - "-Wall", - "-Wextra", - "-Werror", - "-Wno-unused-parameter", - // TODO(b/123097103): annotate InputDispatcher and uncomment the following line - //"-Wthread-safety", // TODO(b/23084678): Move inputflinger to its own process and mark it hidden //-fvisibility=hidden ], @@ -55,15 +61,14 @@ cc_library_shared { } - cc_library_headers { - name: "libinputflinger_headers", - - export_include_dirs: ["include"], + name: "libinputflinger_headers", + export_include_dirs: ["include"], } cc_library_shared { name: "libinputreader", + defaults: ["inputflinger_defaults"], srcs: [ "EventHub.cpp", @@ -73,17 +78,16 @@ cc_library_shared { ], shared_libs: [ - "libinputflinger_base", "libbase", + "libinputflinger_base", "libcrypto", "libcutils", "libinput", "liblog", - "libutils", "libui", + "libutils", "libhardware_legacy", "libstatslog", - "libutils", ], header_libs: [ @@ -93,17 +97,11 @@ cc_library_shared { export_header_lib_headers: [ "libinputflinger_headers", ], - - cflags: [ - "-Wall", - "-Wextra", - "-Werror", - "-Wno-unused-parameter", - ], } cc_library_shared { name: "libinputflinger_base", + defaults: ["inputflinger_defaults"], srcs: [ "InputListener.cpp", @@ -124,24 +122,17 @@ cc_library_shared { export_header_lib_headers: [ "libinputflinger_headers", ], - - cflags: [ - "-Wall", - "-Wextra", - "-Werror", - "-Wno-unused-parameter", - ], } cc_library_shared { name: "libinputreporter", + defaults: ["inputflinger_defaults"], srcs: [ "InputReporter.cpp", ], shared_libs: [ - "libbase", "liblog", "libutils", ], @@ -153,13 +144,6 @@ cc_library_shared { export_header_lib_headers: [ "libinputflinger_headers", ], - - cflags: [ - "-Wall", - "-Wextra", - "-Werror", - "-Wno-unused-parameter", - ], } subdirs = [ diff --git a/services/inputflinger/BlockingQueue.h b/services/inputflinger/BlockingQueue.h index c9eb683fcb..4b16027259 100644 --- a/services/inputflinger/BlockingQueue.h +++ b/services/inputflinger/BlockingQueue.h @@ -17,6 +17,7 @@ #ifndef _UI_INPUT_BLOCKING_QUEUE_H #define _UI_INPUT_BLOCKING_QUEUE_H +#include "android-base/thread_annotations.h" #include <condition_variable> #include <mutex> #include <vector> @@ -43,10 +44,14 @@ public: */ T pop() { std::unique_lock<std::mutex> lock(mLock); - mHasElements.wait(lock, [this]{ return !this->mQueue.empty(); }); + android::base::ScopedLockAssertion assumeLock(mLock); + mHasElements.wait(lock, [this]{ + android::base::ScopedLockAssertion assumeLock(mLock); + return !this->mQueue.empty(); + }); T t = std::move(mQueue.front()); mQueue.erase(mQueue.begin()); - return std::move(t); + return t; }; /** @@ -56,17 +61,19 @@ public: * Return false if the queue is full. */ bool push(T&& t) { - std::unique_lock<std::mutex> lock(mLock); - if (mQueue.size() == mCapacity) { - return false; + { + std::scoped_lock lock(mLock); + if (mQueue.size() == mCapacity) { + return false; + } + mQueue.push_back(std::move(t)); } - mQueue.push_back(std::move(t)); mHasElements.notify_one(); return true; }; void erase(const std::function<bool(const T&)>& lambda) { - std::unique_lock<std::mutex> lock(mLock); + std::scoped_lock lock(mLock); mQueue.erase(std::remove_if(mQueue.begin(), mQueue.end(), [&lambda](const T& t) { return lambda(t); }), mQueue.end()); } @@ -91,7 +98,7 @@ public: } private: - size_t mCapacity; + const size_t mCapacity; /** * Used to signal that mQueue is non-empty. */ @@ -100,7 +107,7 @@ private: * Lock for accessing and waiting on elements. */ std::mutex mLock; - std::vector<T> mQueue; //GUARDED_BY(mLock) + std::vector<T> mQueue GUARDED_BY(mLock); }; diff --git a/services/inputflinger/InputClassifier.h b/services/inputflinger/InputClassifier.h index 4b9dae275b..b97357dfd7 100644 --- a/services/inputflinger/InputClassifier.h +++ b/services/inputflinger/InputClassifier.h @@ -17,6 +17,7 @@ #ifndef _UI_INPUT_CLASSIFIER_H #define _UI_INPUT_CLASSIFIER_H +#include <android-base/thread_annotations.h> #include <utils/RefBase.h> #include <unordered_map> #include <thread> @@ -151,7 +152,7 @@ private: * getClassification / setClassification methods. */ std::unordered_map<int32_t /*deviceId*/, MotionClassification> - mClassifications; //GUARDED_BY(mLock); + mClassifications GUARDED_BY(mLock); /** * Set the current classification for a given device. */ @@ -161,7 +162,7 @@ private: */ MotionClassification getClassification(int32_t deviceId); void updateClassification(int32_t deviceId, nsecs_t eventTime, - MotionClassification classification); + MotionClassification classification); /** * Clear all current classifications */ @@ -172,8 +173,8 @@ private: * * Accessed indirectly by both InputClassifier thread and the thread that receives notifyMotion. */ - std::unordered_map<int32_t /*deviceId*/, nsecs_t /*downTime*/> - mLastDownTimes; //GUARDED_BY(mLock); + std::unordered_map<int32_t /*deviceId*/, nsecs_t /*downTime*/> mLastDownTimes GUARDED_BY(mLock); + void updateLastDownTime(int32_t deviceId, nsecs_t downTime); /** diff --git a/services/inputflinger/InputDispatcher.cpp b/services/inputflinger/InputDispatcher.cpp index 7ff8b20a7e..2ffd0a800b 100644 --- a/services/inputflinger/InputDispatcher.cpp +++ b/services/inputflinger/InputDispatcher.cpp @@ -401,7 +401,7 @@ void InputDispatcher::dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) { case EventEntry::TYPE_KEY: { KeyEntry* typedEntry = static_cast<KeyEntry*>(mPendingEvent); if (isAppSwitchDue) { - if (isAppSwitchKeyEventLocked(typedEntry)) { + if (isAppSwitchKeyEvent(typedEntry)) { resetPendingAppSwitchLocked(true); isAppSwitchDue = false; } else if (dropReason == DROP_REASON_NOT_DROPPED) { @@ -409,7 +409,7 @@ void InputDispatcher::dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) { } } if (dropReason == DROP_REASON_NOT_DROPPED - && isStaleEventLocked(currentTime, typedEntry)) { + && isStaleEvent(currentTime, typedEntry)) { dropReason = DROP_REASON_STALE; } if (dropReason == DROP_REASON_NOT_DROPPED && mNextUnblockedEvent) { @@ -425,7 +425,7 @@ void InputDispatcher::dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) { dropReason = DROP_REASON_APP_SWITCH; } if (dropReason == DROP_REASON_NOT_DROPPED - && isStaleEventLocked(currentTime, typedEntry)) { + && isStaleEvent(currentTime, typedEntry)) { dropReason = DROP_REASON_STALE; } if (dropReason == DROP_REASON_NOT_DROPPED && mNextUnblockedEvent) { @@ -463,7 +463,7 @@ bool InputDispatcher::enqueueInboundEventLocked(EventEntry* entry) { // If the application takes too long to catch up then we drop all events preceding // the app switch key. KeyEntry* keyEntry = static_cast<KeyEntry*>(entry); - if (isAppSwitchKeyEventLocked(keyEntry)) { + if (isAppSwitchKeyEvent(keyEntry)) { if (keyEntry->action == AKEY_EVENT_ACTION_DOWN) { mAppSwitchSawKeyDown = true; } else if (keyEntry->action == AKEY_EVENT_ACTION_UP) { @@ -615,13 +615,13 @@ void InputDispatcher::dropInboundEventLocked(EventEntry* entry, DropReason dropR } } -bool InputDispatcher::isAppSwitchKeyCode(int32_t keyCode) { +static bool isAppSwitchKeyCode(int32_t keyCode) { return keyCode == AKEYCODE_HOME || keyCode == AKEYCODE_ENDCALL || keyCode == AKEYCODE_APP_SWITCH; } -bool InputDispatcher::isAppSwitchKeyEventLocked(KeyEntry* keyEntry) { +bool InputDispatcher::isAppSwitchKeyEvent(KeyEntry* keyEntry) { return ! (keyEntry->flags & AKEY_EVENT_FLAG_CANCELED) && isAppSwitchKeyCode(keyEntry->keyCode) && (keyEntry->policyFlags & POLICY_FLAG_TRUSTED) @@ -644,7 +644,7 @@ void InputDispatcher::resetPendingAppSwitchLocked(bool handled) { #endif } -bool InputDispatcher::isStaleEventLocked(nsecs_t currentTime, EventEntry* entry) { +bool InputDispatcher::isStaleEvent(nsecs_t currentTime, EventEntry* entry) { return currentTime - entry->eventTime >= STALE_EVENT_TIMEOUT; } @@ -756,7 +756,7 @@ bool InputDispatcher::dispatchConfigurationChangedLocked( // Enqueue a command to run outside the lock to tell the policy that the configuration changed. CommandEntry* commandEntry = postCommandLocked( - & InputDispatcher::doNotifyConfigurationChangedInterruptible); + & InputDispatcher::doNotifyConfigurationChangedLockedInterruptible); commandEntry->eventTime = entry->eventTime; return true; } @@ -811,7 +811,7 @@ bool InputDispatcher::dispatchKeyLocked(nsecs_t currentTime, KeyEntry* entry, entry->dispatchInProgress = true; - logOutboundKeyDetailsLocked("dispatchKey - ", entry); + logOutboundKeyDetails("dispatchKey - ", entry); } // Handle case where the policy asked us to try again later last time. @@ -878,7 +878,7 @@ bool InputDispatcher::dispatchKeyLocked(nsecs_t currentTime, KeyEntry* entry, return true; } -void InputDispatcher::logOutboundKeyDetailsLocked(const char* prefix, const KeyEntry* entry) { +void InputDispatcher::logOutboundKeyDetails(const char* prefix, const KeyEntry* entry) { #if DEBUG_OUTBOUND_EVENT_DETAILS ALOGD("%seventTime=%" PRId64 ", deviceId=%d, source=0x%x, displayId=%" PRId32 ", " "policyFlags=0x%x, action=0x%x, flags=0x%x, keyCode=0x%x, scanCode=0x%x, " @@ -896,7 +896,7 @@ bool InputDispatcher::dispatchMotionLocked( if (! entry->dispatchInProgress) { entry->dispatchInProgress = true; - logOutboundMotionDetailsLocked("dispatchMotion - ", entry); + logOutboundMotionDetails("dispatchMotion - ", entry); } // Clean up if dropping the event. @@ -968,7 +968,7 @@ bool InputDispatcher::dispatchMotionLocked( } -void InputDispatcher::logOutboundMotionDetailsLocked(const char* prefix, const MotionEntry* entry) { +void InputDispatcher::logOutboundMotionDetails(const char* prefix, const MotionEntry* entry) { #if DEBUG_OUTBOUND_EVENT_DETAILS ALOGD("%seventTime=%" PRId64 ", deviceId=%d, source=0x%x, displayId=%" PRId32 ", policyFlags=0x%x, " @@ -1049,7 +1049,7 @@ int32_t InputDispatcher::handleTargetsNotReadyLocked(nsecs_t currentTime, if (mInputTargetWaitCause != INPUT_TARGET_WAIT_CAUSE_APPLICATION_NOT_READY) { #if DEBUG_FOCUS ALOGD("Waiting for application to become ready for input: %s. Reason: %s", - getApplicationWindowLabelLocked(applicationHandle, windowHandle).c_str(), + getApplicationWindowLabel(applicationHandle, windowHandle).c_str(), reason); #endif nsecs_t timeout; @@ -1233,8 +1233,7 @@ int32_t InputDispatcher::findFocusedWindowTargetsLocked(nsecs_t currentTime, Failed: Unresponsive: nsecs_t timeSpentWaitingForApplication = getTimeSpentWaitingForApplicationLocked(currentTime); - updateDispatchStatisticsLocked(currentTime, entry, - injectionResult, timeSpentWaitingForApplication); + updateDispatchStatistics(currentTime, entry, injectionResult, timeSpentWaitingForApplication); #if DEBUG_FOCUS ALOGD("findFocusedWindow finished: injectionResult=%d, " "timeSpentWaitingForApplication=%0.1fms", @@ -1654,8 +1653,7 @@ Unresponsive: mTempTouchState.reset(); nsecs_t timeSpentWaitingForApplication = getTimeSpentWaitingForApplicationLocked(currentTime); - updateDispatchStatisticsLocked(currentTime, entry, - injectionResult, timeSpentWaitingForApplication); + updateDispatchStatistics(currentTime, entry, injectionResult, timeSpentWaitingForApplication); #if DEBUG_FOCUS ALOGD("findTouchedWindow finished: injectionResult=%d, injectionPermission=%d, " "timeSpentWaitingForApplication=%0.1fms", @@ -1857,7 +1855,7 @@ std::string InputDispatcher::checkWindowReadyForMoreInputLocked(nsecs_t currentT return ""; } -std::string InputDispatcher::getApplicationWindowLabelLocked( +std::string InputDispatcher::getApplicationWindowLabel( const sp<InputApplicationHandle>& applicationHandle, const sp<InputWindowHandle>& windowHandle) { if (applicationHandle != nullptr) { @@ -1956,7 +1954,7 @@ void InputDispatcher::prepareDispatchCycleLocked(nsecs_t currentTime, #if DEBUG_FOCUS ALOGD("channel '%s' ~ Split motion event.", connection->getInputChannelName().c_str()); - logOutboundMotionDetailsLocked(" ", splitMotionEntry); + logOutboundMotionDetails(" ", splitMotionEntry); #endif enqueueDispatchEntriesLocked(currentTime, connection, splitMotionEntry, inputTarget); @@ -2076,12 +2074,12 @@ void InputDispatcher::enqueueDispatchEntryLocked( // Remember that we are waiting for this dispatch to complete. if (dispatchEntry->hasForegroundTarget()) { - incrementPendingForegroundDispatchesLocked(eventEntry); + incrementPendingForegroundDispatches(eventEntry); } // Enqueue the dispatch entry. connection->outboundQueue.enqueueAtTail(dispatchEntry); - traceOutboundQueueLengthLocked(connection); + traceOutboundQueueLength(connection); } void InputDispatcher::startDispatchCycleLocked(nsecs_t currentTime, @@ -2196,9 +2194,9 @@ void InputDispatcher::startDispatchCycleLocked(nsecs_t currentTime, // Re-enqueue the event on the wait queue. connection->outboundQueue.dequeue(dispatchEntry); - traceOutboundQueueLengthLocked(connection); + traceOutboundQueueLength(connection); connection->waitQueue.enqueueAtTail(dispatchEntry); - traceWaitQueueLengthLocked(connection); + traceWaitQueueLength(connection); } } @@ -2229,9 +2227,9 @@ void InputDispatcher::abortBrokenDispatchCycleLocked(nsecs_t currentTime, // Clear the dispatch queues. drainDispatchQueueLocked(&connection->outboundQueue); - traceOutboundQueueLengthLocked(connection); + traceOutboundQueueLength(connection); drainDispatchQueueLocked(&connection->waitQueue); - traceWaitQueueLengthLocked(connection); + traceWaitQueueLength(connection); // The connection appears to be unrecoverably broken. // Ignore already broken or zombie connections. @@ -2323,7 +2321,7 @@ int InputDispatcher::handleReceiveCallback(int fd, int events, void* data) { } // release lock } -void InputDispatcher::synthesizeCancelationEventsForAllConnectionsLocked( +void InputDispatcher::synthesizeCancelationEventsForAllConnectionsLocked ( const CancelationOptions& options) { for (size_t i = 0; i < mConnectionsByFd.size(); i++) { synthesizeCancelationEventsForConnectionLocked( @@ -2331,7 +2329,7 @@ void InputDispatcher::synthesizeCancelationEventsForAllConnectionsLocked( } } -void InputDispatcher::synthesizeCancelationEventsForMonitorsLocked( +void InputDispatcher::synthesizeCancelationEventsForMonitorsLocked ( const CancelationOptions& options) { for (auto& it : mMonitoringChannelsByDisplay) { const Vector<sp<InputChannel>>& monitoringChannels = it.second; @@ -2374,11 +2372,11 @@ void InputDispatcher::synthesizeCancelationEventsForConnectionLocked( EventEntry* cancelationEventEntry = cancelationEvents.itemAt(i); switch (cancelationEventEntry->type) { case EventEntry::TYPE_KEY: - logOutboundKeyDetailsLocked("cancel - ", + logOutboundKeyDetails("cancel - ", static_cast<KeyEntry*>(cancelationEventEntry)); break; case EventEntry::TYPE_MOTION: - logOutboundMotionDetailsLocked("cancel - ", + logOutboundMotionDetails("cancel - ", static_cast<MotionEntry*>(cancelationEventEntry)); break; } @@ -2994,7 +2992,7 @@ void InputDispatcher::setInjectionResultLocked(EventEntry* entry, int32_t inject } } -void InputDispatcher::incrementPendingForegroundDispatchesLocked(EventEntry* entry) { +void InputDispatcher::incrementPendingForegroundDispatches(EventEntry* entry) { InjectionState* injectionState = entry->injectionState; if (injectionState) { injectionState->pendingForegroundDispatches += 1; @@ -3014,7 +3012,7 @@ void InputDispatcher::decrementPendingForegroundDispatchesLocked(EventEntry* ent Vector<sp<InputWindowHandle>> InputDispatcher::getWindowHandlesLocked(int32_t displayId) const { std::unordered_map<int32_t, Vector<sp<InputWindowHandle>>>::const_iterator it = - mWindowHandlesByDisplay.find(displayId); + mWindowHandlesByDisplay.find(displayId); if(it != mWindowHandlesByDisplay.end()) { return it->second; } @@ -3038,8 +3036,7 @@ sp<InputWindowHandle> InputDispatcher::getWindowHandleLocked( return nullptr; } -bool InputDispatcher::hasWindowHandleLocked( - const sp<InputWindowHandle>& windowHandle) const { +bool InputDispatcher::hasWindowHandleLocked(const sp<InputWindowHandle>& windowHandle) const { for (auto& it : mWindowHandlesByDisplay) { const Vector<sp<InputWindowHandle>> windowHandles = it.second; size_t numWindows = windowHandles.size(); @@ -3884,7 +3881,7 @@ void InputDispatcher::onANRLocked( float waitDuration = (currentTime - waitStartTime) * 0.000001f; ALOGI("Application is not responding: %s. " "It has been %0.1fms since event, %0.1fms since wait started. Reason: %s", - getApplicationWindowLabelLocked(applicationHandle, windowHandle).c_str(), + getApplicationWindowLabel(applicationHandle, windowHandle).c_str(), dispatchLatency, waitDuration, reason); // Capture a record of the InputDispatcher state at the time of the ANR. @@ -3897,7 +3894,7 @@ void InputDispatcher::onANRLocked( mLastANRState += INDENT "ANR:\n"; mLastANRState += StringPrintf(INDENT2 "Time: %s\n", timestr); mLastANRState += StringPrintf(INDENT2 "Window: %s\n", - getApplicationWindowLabelLocked(applicationHandle, windowHandle).c_str()); + getApplicationWindowLabel(applicationHandle, windowHandle).c_str()); mLastANRState += StringPrintf(INDENT2 "DispatchLatency: %0.1fms\n", dispatchLatency); mLastANRState += StringPrintf(INDENT2 "WaitDuration: %0.1fms\n", waitDuration); mLastANRState += StringPrintf(INDENT2 "Reason: %s\n", reason); @@ -3911,7 +3908,7 @@ void InputDispatcher::onANRLocked( commandEntry->reason = reason; } -void InputDispatcher::doNotifyConfigurationChangedInterruptible( +void InputDispatcher::doNotifyConfigurationChangedLockedInterruptible ( CommandEntry* commandEntry) { mLock.unlock(); @@ -4027,10 +4024,10 @@ void InputDispatcher::doDispatchCycleFinishedLockedInterruptible( // a few things. if (dispatchEntry == connection->findWaitQueueEntry(seq)) { connection->waitQueue.dequeue(dispatchEntry); - traceWaitQueueLengthLocked(connection); + traceWaitQueueLength(connection); if (restartEvent && connection->status == Connection::STATUS_NORMAL) { connection->outboundQueue.enqueueAtHead(dispatchEntry); - traceOutboundQueueLengthLocked(connection); + traceOutboundQueueLength(connection); } else { releaseDispatchEntryLocked(dispatchEntry); } @@ -4242,7 +4239,7 @@ void InputDispatcher::initializeKeyEvent(KeyEvent* event, const KeyEntry* entry) entry->downTime, entry->eventTime); } -void InputDispatcher::updateDispatchStatisticsLocked(nsecs_t currentTime, const EventEntry* entry, +void InputDispatcher::updateDispatchStatistics(nsecs_t currentTime, const EventEntry* entry, int32_t injectionResult, nsecs_t timeSpentWaitingForApplication) { // TODO Write some statistics about how long we spend waiting. } @@ -4253,7 +4250,7 @@ void InputDispatcher::traceInboundQueueLengthLocked() { } } -void InputDispatcher::traceOutboundQueueLengthLocked(const sp<Connection>& connection) { +void InputDispatcher::traceOutboundQueueLength(const sp<Connection>& connection) { if (ATRACE_ENABLED()) { char counterName[40]; snprintf(counterName, sizeof(counterName), "oq:%s", connection->getWindowName().c_str()); @@ -4261,7 +4258,7 @@ void InputDispatcher::traceOutboundQueueLengthLocked(const sp<Connection>& conne } } -void InputDispatcher::traceWaitQueueLengthLocked(const sp<Connection>& connection) { +void InputDispatcher::traceWaitQueueLength(const sp<Connection>& connection) { if (ATRACE_ENABLED()) { char counterName[40]; snprintf(counterName, sizeof(counterName), "wq:%s", connection->getWindowName().c_str()); diff --git a/services/inputflinger/InputDispatcher.h b/services/inputflinger/InputDispatcher.h index 595b01d46c..ecfeb6cac9 100644 --- a/services/inputflinger/InputDispatcher.h +++ b/services/inputflinger/InputDispatcher.h @@ -888,57 +888,58 @@ private: sp<Looper> mLooper; - EventEntry* mPendingEvent; - Queue<EventEntry> mInboundQueue; - Queue<EventEntry> mRecentQueue; - Queue<CommandEntry> mCommandQueue; + EventEntry* mPendingEvent GUARDED_BY(mLock); + Queue<EventEntry> mInboundQueue GUARDED_BY(mLock); + Queue<EventEntry> mRecentQueue GUARDED_BY(mLock); + Queue<CommandEntry> mCommandQueue GUARDED_BY(mLock); - DropReason mLastDropReason; + DropReason mLastDropReason GUARDED_BY(mLock); - void dispatchOnceInnerLocked(nsecs_t* nextWakeupTime); + void dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) REQUIRES(mLock); // Enqueues an inbound event. Returns true if mLooper->wake() should be called. - bool enqueueInboundEventLocked(EventEntry* entry); + bool enqueueInboundEventLocked(EventEntry* entry) REQUIRES(mLock); // Cleans up input state when dropping an inbound event. - void dropInboundEventLocked(EventEntry* entry, DropReason dropReason); + void dropInboundEventLocked(EventEntry* entry, DropReason dropReason) REQUIRES(mLock); // Adds an event to a queue of recent events for debugging purposes. - void addRecentEventLocked(EventEntry* entry); + void addRecentEventLocked(EventEntry* entry) REQUIRES(mLock); // App switch latency optimization. - bool mAppSwitchSawKeyDown; - nsecs_t mAppSwitchDueTime; + bool mAppSwitchSawKeyDown GUARDED_BY(mLock); + nsecs_t mAppSwitchDueTime GUARDED_BY(mLock); - static bool isAppSwitchKeyCode(int32_t keyCode); - bool isAppSwitchKeyEventLocked(KeyEntry* keyEntry); - bool isAppSwitchPendingLocked(); - void resetPendingAppSwitchLocked(bool handled); + bool isAppSwitchKeyEvent(KeyEntry* keyEntry); + bool isAppSwitchPendingLocked() REQUIRES(mLock); + void resetPendingAppSwitchLocked(bool handled) REQUIRES(mLock); // Stale event latency optimization. - static bool isStaleEventLocked(nsecs_t currentTime, EventEntry* entry); + static bool isStaleEvent(nsecs_t currentTime, EventEntry* entry); // Blocked event latency optimization. Drops old events when the user intends // to transfer focus to a new application. - EventEntry* mNextUnblockedEvent; + EventEntry* mNextUnblockedEvent GUARDED_BY(mLock); sp<InputWindowHandle> findTouchedWindowAtLocked(int32_t displayId, int32_t x, int32_t y, - bool addOutsideTargets = false, bool addPortalWindows = false); + bool addOutsideTargets = false, bool addPortalWindows = false) REQUIRES(mLock); // All registered connections mapped by channel file descriptor. - KeyedVector<int, sp<Connection> > mConnectionsByFd; + KeyedVector<int, sp<Connection> > mConnectionsByFd GUARDED_BY(mLock); struct IBinderHash { std::size_t operator()(const sp<IBinder>& b) const { return std::hash<IBinder *>{}(b.get()); } }; - std::unordered_map<sp<IBinder>, sp<InputChannel>, IBinderHash> mInputChannelsByToken; + std::unordered_map<sp<IBinder>, sp<InputChannel>, IBinderHash> mInputChannelsByToken + GUARDED_BY(mLock); - ssize_t getConnectionIndexLocked(const sp<InputChannel>& inputChannel); + ssize_t getConnectionIndexLocked(const sp<InputChannel>& inputChannel) REQUIRES(mLock); // Input channels that will receive a copy of all input events sent to the provided display. - std::unordered_map<int32_t, Vector<sp<InputChannel>>> mMonitoringChannelsByDisplay; + std::unordered_map<int32_t, Vector<sp<InputChannel>>> mMonitoringChannelsByDisplay + GUARDED_BY(mLock); // Event injection and synchronization. Condition mInjectionResultAvailableCondition; @@ -946,17 +947,17 @@ private: void setInjectionResultLocked(EventEntry* entry, int32_t injectionResult); Condition mInjectionSyncFinishedCondition; - void incrementPendingForegroundDispatchesLocked(EventEntry* entry); + void incrementPendingForegroundDispatches(EventEntry* entry); void decrementPendingForegroundDispatchesLocked(EventEntry* entry); // Key repeat tracking. struct KeyRepeatState { KeyEntry* lastKeyEntry; // or null if no repeat nsecs_t nextRepeatTime; - } mKeyRepeatState; + } mKeyRepeatState GUARDED_BY(mLock); - void resetKeyRepeatLocked(); - KeyEntry* synthesizeKeyRepeatLocked(nsecs_t currentTime); + void resetKeyRepeatLocked() REQUIRES(mLock); + KeyEntry* synthesizeKeyRepeatLocked(nsecs_t currentTime) REQUIRES(mLock); // Key replacement tracking struct KeyReplacement { @@ -970,39 +971,42 @@ private: } }; // Maps the key code replaced, device id tuple to the key code it was replaced with - KeyedVector<KeyReplacement, int32_t> mReplacedKeys; + KeyedVector<KeyReplacement, int32_t> mReplacedKeys GUARDED_BY(mLock); // Process certain Meta + Key combinations void accelerateMetaShortcuts(const int32_t deviceId, const int32_t action, int32_t& keyCode, int32_t& metaState); // Deferred command processing. - bool haveCommandsLocked() const; - bool runCommandsLockedInterruptible(); - CommandEntry* postCommandLocked(Command command); + bool haveCommandsLocked() const REQUIRES(mLock); + bool runCommandsLockedInterruptible() REQUIRES(mLock); + CommandEntry* postCommandLocked(Command command) REQUIRES(mLock); // Input filter processing. - bool shouldSendKeyToInputFilterLocked(const NotifyKeyArgs* args); - bool shouldSendMotionToInputFilterLocked(const NotifyMotionArgs* args); + bool shouldSendKeyToInputFilterLocked(const NotifyKeyArgs* args) REQUIRES(mLock); + bool shouldSendMotionToInputFilterLocked(const NotifyMotionArgs* args) REQUIRES(mLock); // Inbound event processing. - void drainInboundQueueLocked(); - void releasePendingEventLocked(); - void releaseInboundEventLocked(EventEntry* entry); + void drainInboundQueueLocked() REQUIRES(mLock); + void releasePendingEventLocked() REQUIRES(mLock); + void releaseInboundEventLocked(EventEntry* entry) REQUIRES(mLock); // Dispatch state. - bool mDispatchEnabled; - bool mDispatchFrozen; - bool mInputFilterEnabled; + bool mDispatchEnabled GUARDED_BY(mLock); + bool mDispatchFrozen GUARDED_BY(mLock); + bool mInputFilterEnabled GUARDED_BY(mLock); - std::unordered_map<int32_t, Vector<sp<InputWindowHandle>>> mWindowHandlesByDisplay; + std::unordered_map<int32_t, Vector<sp<InputWindowHandle>>> mWindowHandlesByDisplay + GUARDED_BY(mLock); // Get window handles by display, return an empty vector if not found. - Vector<sp<InputWindowHandle>> getWindowHandlesLocked(int32_t displayId) const; - sp<InputWindowHandle> getWindowHandleLocked(const sp<IBinder>& windowHandleToken) const; - sp<InputChannel> getInputChannelLocked(const sp<IBinder>& windowToken) const; - bool hasWindowHandleLocked(const sp<InputWindowHandle>& windowHandle) const; + Vector<sp<InputWindowHandle>> getWindowHandlesLocked(int32_t displayId) const REQUIRES(mLock); + sp<InputWindowHandle> getWindowHandleLocked(const sp<IBinder>& windowHandleToken) const + REQUIRES(mLock); + sp<InputChannel> getInputChannelLocked(const sp<IBinder>& windowToken) const REQUIRES(mLock); + bool hasWindowHandleLocked(const sp<InputWindowHandle>& windowHandle) const REQUIRES(mLock); // Focus tracking for keys, trackball, etc. - std::unordered_map<int32_t, sp<InputWindowHandle>> mFocusedWindowHandlesByDisplay; + std::unordered_map<int32_t, sp<InputWindowHandle>> mFocusedWindowHandlesByDisplay + GUARDED_BY(mLock); // Focus tracking for touch. struct TouchedWindow { @@ -1037,34 +1041,35 @@ private: bool isSlippery() const; }; - KeyedVector<int32_t, TouchState> mTouchStatesByDisplay; - TouchState mTempTouchState; + KeyedVector<int32_t, TouchState> mTouchStatesByDisplay GUARDED_BY(mLock); + TouchState mTempTouchState GUARDED_BY(mLock); // Focused applications. - std::unordered_map<int32_t, sp<InputApplicationHandle>> mFocusedApplicationHandlesByDisplay; + std::unordered_map<int32_t, sp<InputApplicationHandle>> mFocusedApplicationHandlesByDisplay + GUARDED_BY(mLock); // Top focused display. - int32_t mFocusedDisplayId; + int32_t mFocusedDisplayId GUARDED_BY(mLock); // Dispatcher state at time of last ANR. - std::string mLastANRState; + std::string mLastANRState GUARDED_BY(mLock); // Dispatch inbound events. bool dispatchConfigurationChangedLocked( - nsecs_t currentTime, ConfigurationChangedEntry* entry); + nsecs_t currentTime, ConfigurationChangedEntry* entry) REQUIRES(mLock); bool dispatchDeviceResetLocked( - nsecs_t currentTime, DeviceResetEntry* entry); + nsecs_t currentTime, DeviceResetEntry* entry) REQUIRES(mLock); bool dispatchKeyLocked( nsecs_t currentTime, KeyEntry* entry, - DropReason* dropReason, nsecs_t* nextWakeupTime); + DropReason* dropReason, nsecs_t* nextWakeupTime) REQUIRES(mLock); bool dispatchMotionLocked( nsecs_t currentTime, MotionEntry* entry, - DropReason* dropReason, nsecs_t* nextWakeupTime); + DropReason* dropReason, nsecs_t* nextWakeupTime) REQUIRES(mLock); void dispatchEventLocked(nsecs_t currentTime, EventEntry* entry, - const Vector<InputTarget>& inputTargets); + const Vector<InputTarget>& inputTargets) REQUIRES(mLock); - void logOutboundKeyDetailsLocked(const char* prefix, const KeyEntry* entry); - void logOutboundMotionDetailsLocked(const char* prefix, const MotionEntry* entry); + void logOutboundKeyDetails(const char* prefix, const KeyEntry* entry); + void logOutboundMotionDetails(const char* prefix, const MotionEntry* entry); // Keeping track of ANR timeouts. enum InputTargetWaitCause { @@ -1073,130 +1078,133 @@ private: INPUT_TARGET_WAIT_CAUSE_APPLICATION_NOT_READY, }; - InputTargetWaitCause mInputTargetWaitCause; - nsecs_t mInputTargetWaitStartTime; - nsecs_t mInputTargetWaitTimeoutTime; - bool mInputTargetWaitTimeoutExpired; - sp<IBinder> mInputTargetWaitApplicationToken; + InputTargetWaitCause mInputTargetWaitCause GUARDED_BY(mLock); + nsecs_t mInputTargetWaitStartTime GUARDED_BY(mLock); + nsecs_t mInputTargetWaitTimeoutTime GUARDED_BY(mLock); + bool mInputTargetWaitTimeoutExpired GUARDED_BY(mLock); + sp<IBinder> mInputTargetWaitApplicationToken GUARDED_BY(mLock); // Contains the last window which received a hover event. - sp<InputWindowHandle> mLastHoverWindowHandle; + sp<InputWindowHandle> mLastHoverWindowHandle GUARDED_BY(mLock); // Finding targets for input events. int32_t handleTargetsNotReadyLocked(nsecs_t currentTime, const EventEntry* entry, const sp<InputApplicationHandle>& applicationHandle, const sp<InputWindowHandle>& windowHandle, - nsecs_t* nextWakeupTime, const char* reason); + nsecs_t* nextWakeupTime, const char* reason) REQUIRES(mLock); - void removeWindowByTokenLocked(const sp<IBinder>& token); + void removeWindowByTokenLocked(const sp<IBinder>& token) REQUIRES(mLock); void resumeAfterTargetsNotReadyTimeoutLocked(nsecs_t newTimeout, - const sp<InputChannel>& inputChannel); - nsecs_t getTimeSpentWaitingForApplicationLocked(nsecs_t currentTime); - void resetANRTimeoutsLocked(); + const sp<InputChannel>& inputChannel) REQUIRES(mLock); + nsecs_t getTimeSpentWaitingForApplicationLocked(nsecs_t currentTime) REQUIRES(mLock); + void resetANRTimeoutsLocked() REQUIRES(mLock); int32_t getTargetDisplayId(const EventEntry* entry); int32_t findFocusedWindowTargetsLocked(nsecs_t currentTime, const EventEntry* entry, - Vector<InputTarget>& inputTargets, nsecs_t* nextWakeupTime); + Vector<InputTarget>& inputTargets, nsecs_t* nextWakeupTime) REQUIRES(mLock); int32_t findTouchedWindowTargetsLocked(nsecs_t currentTime, const MotionEntry* entry, Vector<InputTarget>& inputTargets, nsecs_t* nextWakeupTime, - bool* outConflictingPointerActions); + bool* outConflictingPointerActions) REQUIRES(mLock); void addWindowTargetLocked(const sp<InputWindowHandle>& windowHandle, - int32_t targetFlags, BitSet32 pointerIds, Vector<InputTarget>& inputTargets); + int32_t targetFlags, BitSet32 pointerIds, Vector<InputTarget>& inputTargets) + REQUIRES(mLock); void addMonitoringTargetsLocked(Vector<InputTarget>& inputTargets, int32_t displayId, - float xOffset = 0, float yOffset = 0); + float xOffset = 0, float yOffset = 0) REQUIRES(mLock); - void pokeUserActivityLocked(const EventEntry* eventEntry); + void pokeUserActivityLocked(const EventEntry* eventEntry) REQUIRES(mLock); bool checkInjectionPermission(const sp<InputWindowHandle>& windowHandle, const InjectionState* injectionState); bool isWindowObscuredAtPointLocked(const sp<InputWindowHandle>& windowHandle, - int32_t x, int32_t y) const; - bool isWindowObscuredLocked(const sp<InputWindowHandle>& windowHandle) const; - std::string getApplicationWindowLabelLocked(const sp<InputApplicationHandle>& applicationHandle, + int32_t x, int32_t y) const REQUIRES(mLock); + bool isWindowObscuredLocked(const sp<InputWindowHandle>& windowHandle) const REQUIRES(mLock); + std::string getApplicationWindowLabel(const sp<InputApplicationHandle>& applicationHandle, const sp<InputWindowHandle>& windowHandle); std::string checkWindowReadyForMoreInputLocked(nsecs_t currentTime, const sp<InputWindowHandle>& windowHandle, const EventEntry* eventEntry, - const char* targetType); + const char* targetType) REQUIRES(mLock); // Manage the dispatch cycle for a single connection. // These methods are deliberately not Interruptible because doing all of the work // with the mutex held makes it easier to ensure that connection invariants are maintained. // If needed, the methods post commands to run later once the critical bits are done. void prepareDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection, - EventEntry* eventEntry, const InputTarget* inputTarget); + EventEntry* eventEntry, const InputTarget* inputTarget) REQUIRES(mLock); void enqueueDispatchEntriesLocked(nsecs_t currentTime, const sp<Connection>& connection, - EventEntry* eventEntry, const InputTarget* inputTarget); + EventEntry* eventEntry, const InputTarget* inputTarget) REQUIRES(mLock); void enqueueDispatchEntryLocked(const sp<Connection>& connection, EventEntry* eventEntry, const InputTarget* inputTarget, int32_t dispatchMode); - void startDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection); + void startDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection) + REQUIRES(mLock); void finishDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection, - uint32_t seq, bool handled); + uint32_t seq, bool handled) REQUIRES(mLock); void abortBrokenDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection, - bool notify); + bool notify) REQUIRES(mLock); void drainDispatchQueueLocked(Queue<DispatchEntry>* queue); void releaseDispatchEntryLocked(DispatchEntry* dispatchEntry); static int handleReceiveCallback(int fd, int events, void* data); void synthesizeCancelationEventsForAllConnectionsLocked( - const CancelationOptions& options); - void synthesizeCancelationEventsForMonitorsLocked(const CancelationOptions& options); + const CancelationOptions& options) REQUIRES(mLock); + void synthesizeCancelationEventsForMonitorsLocked( + const CancelationOptions& options) REQUIRES(mLock); void synthesizeCancelationEventsForInputChannelLocked(const sp<InputChannel>& channel, - const CancelationOptions& options); + const CancelationOptions& options) REQUIRES(mLock); void synthesizeCancelationEventsForConnectionLocked(const sp<Connection>& connection, - const CancelationOptions& options); + const CancelationOptions& options) REQUIRES(mLock); // Splitting motion events across windows. MotionEntry* splitMotionEvent(const MotionEntry* originalMotionEntry, BitSet32 pointerIds); // Reset and drop everything the dispatcher is doing. - void resetAndDropEverythingLocked(const char* reason); + void resetAndDropEverythingLocked(const char* reason) REQUIRES(mLock); // Dump state. - void dumpDispatchStateLocked(std::string& dump); - void logDispatchStateLocked(); + void dumpDispatchStateLocked(std::string& dump) REQUIRES(mLock); + void logDispatchStateLocked() REQUIRES(mLock); // Registration. - void removeMonitorChannelLocked(const sp<InputChannel>& inputChannel); - status_t unregisterInputChannelLocked(const sp<InputChannel>& inputChannel, bool notify); - - // Add or remove a connection to the mActiveConnections vector. - void activateConnectionLocked(Connection* connection); - void deactivateConnectionLocked(Connection* connection); + void removeMonitorChannelLocked(const sp<InputChannel>& inputChannel) REQUIRES(mLock); + status_t unregisterInputChannelLocked(const sp<InputChannel>& inputChannel, bool notify) + REQUIRES(mLock); // Interesting events that we might like to log or tell the framework about. void onDispatchCycleFinishedLocked( - nsecs_t currentTime, const sp<Connection>& connection, uint32_t seq, bool handled); + nsecs_t currentTime, const sp<Connection>& connection, uint32_t seq, bool handled) + REQUIRES(mLock); void onDispatchCycleBrokenLocked( - nsecs_t currentTime, const sp<Connection>& connection); + nsecs_t currentTime, const sp<Connection>& connection) REQUIRES(mLock); void onFocusChangedLocked(const sp<InputWindowHandle>& oldFocus, - const sp<InputWindowHandle>& newFocus); + const sp<InputWindowHandle>& newFocus) REQUIRES(mLock); void onANRLocked( nsecs_t currentTime, const sp<InputApplicationHandle>& applicationHandle, const sp<InputWindowHandle>& windowHandle, - nsecs_t eventTime, nsecs_t waitStartTime, const char* reason); + nsecs_t eventTime, nsecs_t waitStartTime, const char* reason) REQUIRES(mLock); // Outbound policy interactions. - void doNotifyConfigurationChangedInterruptible(CommandEntry* commandEntry); - void doNotifyInputChannelBrokenLockedInterruptible(CommandEntry* commandEntry); - void doNotifyFocusChangedLockedInterruptible(CommandEntry* commandEntry); - void doNotifyANRLockedInterruptible(CommandEntry* commandEntry); - void doInterceptKeyBeforeDispatchingLockedInterruptible(CommandEntry* commandEntry); - void doDispatchCycleFinishedLockedInterruptible(CommandEntry* commandEntry); + void doNotifyConfigurationChangedLockedInterruptible(CommandEntry* commandEntry) + REQUIRES(mLock); + void doNotifyInputChannelBrokenLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); + void doNotifyFocusChangedLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); + void doNotifyANRLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); + void doInterceptKeyBeforeDispatchingLockedInterruptible(CommandEntry* commandEntry) + REQUIRES(mLock); + void doDispatchCycleFinishedLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); bool afterKeyEventLockedInterruptible(const sp<Connection>& connection, - DispatchEntry* dispatchEntry, KeyEntry* keyEntry, bool handled); + DispatchEntry* dispatchEntry, KeyEntry* keyEntry, bool handled) REQUIRES(mLock); bool afterMotionEventLockedInterruptible(const sp<Connection>& connection, DispatchEntry* dispatchEntry, MotionEntry* motionEntry, bool handled); - void doPokeUserActivityLockedInterruptible(CommandEntry* commandEntry); + void doPokeUserActivityLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock); void initializeKeyEvent(KeyEvent* event, const KeyEntry* entry); // Statistics gathering. - void updateDispatchStatisticsLocked(nsecs_t currentTime, const EventEntry* entry, + void updateDispatchStatistics(nsecs_t currentTime, const EventEntry* entry, int32_t injectionResult, nsecs_t timeSpentWaitingForApplication); - void traceInboundQueueLengthLocked(); - void traceOutboundQueueLengthLocked(const sp<Connection>& connection); - void traceWaitQueueLengthLocked(const sp<Connection>& connection); + void traceInboundQueueLengthLocked() REQUIRES(mLock); + void traceOutboundQueueLength(const sp<Connection>& connection); + void traceWaitQueueLength(const sp<Connection>& connection); sp<InputReporterInterface> mReporter; }; |