From c7edaaa0352992ca2d542752e3c37493a4ece953 Mon Sep 17 00:00:00 2001 From: Prabir Pradhan Date: Fri, 15 Mar 2024 15:31:02 +0000 Subject: InputTracer: s/TracedEventArgs/TracedEventMetadata Bug: 210460522 Test: atest inputflinger_tests Change-Id: Ibd4f17fd47adf0e2af3a6910a9d81cc7f83043fe --- .../inputflinger/dispatcher/trace/InputTracer.cpp | 26 +++++++++++----------- .../trace/InputTracingBackendInterface.h | 8 +++---- .../trace/InputTracingPerfettoBackend.cpp | 25 +++++++++++---------- .../dispatcher/trace/InputTracingPerfettoBackend.h | 10 ++++----- .../dispatcher/trace/ThreadedBackend.cpp | 12 +++++----- .../dispatcher/trace/ThreadedBackend.h | 8 +++---- .../inputflinger/tests/FakeInputTracingBackend.cpp | 6 ++--- .../inputflinger/tests/FakeInputTracingBackend.h | 7 +++--- 8 files changed, 52 insertions(+), 50 deletions(-) (limited to 'services') diff --git a/services/inputflinger/dispatcher/trace/InputTracer.cpp b/services/inputflinger/dispatcher/trace/InputTracer.cpp index 55ed5c635c..019283f133 100644 --- a/services/inputflinger/dispatcher/trace/InputTracer.cpp +++ b/services/inputflinger/dispatcher/trace/InputTracer.cpp @@ -61,10 +61,10 @@ TracedEvent createTracedEvent(const KeyEntry& e, EventType type) { e.downTime, e.flags, e.repeatCount, type}; } -void writeEventToBackend(const TracedEvent& event, const TracedEventArgs args, +void writeEventToBackend(const TracedEvent& event, const TracedEventMetadata metadata, InputTracingBackendInterface& backend) { - std::visit(Visitor{[&](const TracedMotionEvent& e) { backend.traceMotionEvent(e, args); }, - [&](const TracedKeyEvent& e) { backend.traceKeyEvent(e, args); }}, + std::visit(Visitor{[&](const TracedMotionEvent& e) { backend.traceMotionEvent(e, metadata); }, + [&](const TracedKeyEvent& e) { backend.traceKeyEvent(e, metadata); }}, event); } @@ -177,9 +177,9 @@ std::unique_ptr InputTracer::traceDerivedEvent( // is dispatched, such as in the case of key fallback events. To account for these cases, // derived events can be traced after the processing is complete for the original event. const auto& event = eventState->events.back(); - const TracedEventArgs traceArgs{.isSecure = eventState->isSecure, - .targets = eventState->targets}; - writeEventToBackend(event, std::move(traceArgs), *mBackend); + const TracedEventMetadata metadata{.isSecure = eventState->isSecure, + .targets = eventState->targets}; + writeEventToBackend(event, std::move(metadata), *mBackend); } return std::make_unique(std::move(eventState), /*isDerived=*/true); } @@ -226,9 +226,9 @@ void InputTracer::traceEventDispatch(const DispatchEntry& dispatchEntry, /*hmac=*/{}, resolvedKeyRepeatCount}; if (eventState->isEventProcessingComplete) { - const TracedEventArgs traceArgs{.isSecure = eventState->isSecure, - .targets = eventState->targets}; - mBackend->traceWindowDispatch(std::move(windowDispatchArgs), std::move(traceArgs)); + const TracedEventMetadata metadata{.isSecure = eventState->isSecure, + .targets = eventState->targets}; + mBackend->traceWindowDispatch(std::move(windowDispatchArgs), std::move(metadata)); } else { eventState->pendingDispatchArgs.emplace_back(std::move(windowDispatchArgs)); } @@ -248,8 +248,8 @@ bool InputTracer::isDerivedCookie(const EventTrackerInterface& cookie) { void InputTracer::EventState::onEventProcessingComplete() { // Write all of the events known so far to the trace. for (const auto& event : events) { - const TracedEventArgs traceArgs{.isSecure = isSecure, .targets = targets}; - writeEventToBackend(event, traceArgs, *tracer.mBackend); + const TracedEventMetadata metadata{.isSecure = isSecure, .targets = targets}; + writeEventToBackend(event, std::move(metadata), *tracer.mBackend); } // Write all pending dispatch args to the trace. for (const auto& windowDispatchArgs : pendingDispatchArgs) { @@ -263,8 +263,8 @@ void InputTracer::EventState::onEventProcessingComplete() { << ": Failed to find a previously traced event that matches the dispatched " "event"; } - const TracedEventArgs traceArgs{.isSecure = isSecure, .targets = targets}; - tracer.mBackend->traceWindowDispatch(windowDispatchArgs, std::move(traceArgs)); + const TracedEventMetadata metadata{.isSecure = isSecure, .targets = targets}; + tracer.mBackend->traceWindowDispatch(windowDispatchArgs, std::move(metadata)); } pendingDispatchArgs.clear(); diff --git a/services/inputflinger/dispatcher/trace/InputTracingBackendInterface.h b/services/inputflinger/dispatcher/trace/InputTracingBackendInterface.h index 3ff7fab91f..bc037b39e4 100644 --- a/services/inputflinger/dispatcher/trace/InputTracingBackendInterface.h +++ b/services/inputflinger/dispatcher/trace/InputTracingBackendInterface.h @@ -92,7 +92,7 @@ struct TracedMotionEvent { using TracedEvent = std::variant; /** Additional information about an input event being traced. */ -struct TracedEventArgs { +struct TracedEventMetadata { // True if the event is targeting at least one secure window. bool isSecure; // The list of possible UIDs that this event could be targeting. @@ -121,13 +121,13 @@ public: virtual ~InputTracingBackendInterface() = default; /** Trace a KeyEvent. */ - virtual void traceKeyEvent(const TracedKeyEvent&, const TracedEventArgs&) = 0; + virtual void traceKeyEvent(const TracedKeyEvent&, const TracedEventMetadata&) = 0; /** Trace a MotionEvent. */ - virtual void traceMotionEvent(const TracedMotionEvent&, const TracedEventArgs&) = 0; + virtual void traceMotionEvent(const TracedMotionEvent&, const TracedEventMetadata&) = 0; /** Trace an event being sent to a window. */ - virtual void traceWindowDispatch(const WindowDispatchArgs&, const TracedEventArgs&) = 0; + virtual void traceWindowDispatch(const WindowDispatchArgs&, const TracedEventMetadata&) = 0; }; } // namespace android::inputdispatcher::trace diff --git a/services/inputflinger/dispatcher/trace/InputTracingPerfettoBackend.cpp b/services/inputflinger/dispatcher/trace/InputTracingPerfettoBackend.cpp index b76bec31b6..b413def815 100644 --- a/services/inputflinger/dispatcher/trace/InputTracingPerfettoBackend.cpp +++ b/services/inputflinger/dispatcher/trace/InputTracingPerfettoBackend.cpp @@ -98,10 +98,10 @@ bool PerfettoBackend::InputEventDataSource::shouldIgnoreTracedInputEvent( } TraceLevel PerfettoBackend::InputEventDataSource::resolveTraceLevel( - const TracedEventArgs& args) const { + const TracedEventMetadata& metadata) const { // Check for matches with the rules in the order that they are defined. for (const auto& rule : mConfig.rules) { - if (ruleMatches(rule, args)) { + if (ruleMatches(rule, metadata)) { return rule.level; } } @@ -110,17 +110,17 @@ TraceLevel PerfettoBackend::InputEventDataSource::resolveTraceLevel( } bool PerfettoBackend::InputEventDataSource::ruleMatches(const TraceRule& rule, - const TracedEventArgs& args) const { + const TracedEventMetadata& metadata) const { // By default, a rule will match all events. Return early if the rule does not match. // Match the event if it is directed to a secure window. - if (rule.matchSecure.has_value() && *rule.matchSecure != args.isSecure) { + if (rule.matchSecure.has_value() && *rule.matchSecure != metadata.isSecure) { return false; } // Match the event if all of its target packages are explicitly allowed in the "match all" list. if (!rule.matchAllPackages.empty() && - !std::all_of(args.targets.begin(), args.targets.end(), [&](const auto& uid) { + !std::all_of(metadata.targets.begin(), metadata.targets.end(), [&](const auto& uid) { return isPermanentlyAllowed(uid) || std::any_of(rule.matchAllPackages.begin(), rule.matchAllPackages.end(), [&](const auto& pkg) { return uid == mUidMap->at(pkg); }); @@ -130,7 +130,7 @@ bool PerfettoBackend::InputEventDataSource::ruleMatches(const TraceRule& rule, // Match the event if any of its target packages are allowed in the "match any" list. if (!rule.matchAnyPackages.empty() && - !std::any_of(args.targets.begin(), args.targets.end(), [&](const auto& uid) { + !std::any_of(metadata.targets.begin(), metadata.targets.end(), [&](const auto& uid) { return std::any_of(rule.matchAnyPackages.begin(), rule.matchAnyPackages.end(), [&](const auto& pkg) { return uid == mUidMap->at(pkg); }); })) { @@ -166,14 +166,14 @@ PerfettoBackend::PerfettoBackend(GetPackageUid getPackagesForUid) } void PerfettoBackend::traceMotionEvent(const TracedMotionEvent& event, - const TracedEventArgs& args) { + const TracedEventMetadata& metadata) { InputEventDataSource::Trace([&](InputEventDataSource::TraceContext ctx) { auto dataSource = ctx.GetDataSourceLocked(); dataSource->initializeUidMap(mGetPackageUid); if (dataSource->shouldIgnoreTracedInputEvent(event.eventType)) { return; } - const TraceLevel traceLevel = dataSource->resolveTraceLevel(args); + const TraceLevel traceLevel = dataSource->resolveTraceLevel(metadata); if (traceLevel == TraceLevel::TRACE_LEVEL_NONE) { return; } @@ -186,14 +186,15 @@ void PerfettoBackend::traceMotionEvent(const TracedMotionEvent& event, }); } -void PerfettoBackend::traceKeyEvent(const TracedKeyEvent& event, const TracedEventArgs& args) { +void PerfettoBackend::traceKeyEvent(const TracedKeyEvent& event, + const TracedEventMetadata& metadata) { InputEventDataSource::Trace([&](InputEventDataSource::TraceContext ctx) { auto dataSource = ctx.GetDataSourceLocked(); dataSource->initializeUidMap(mGetPackageUid); if (dataSource->shouldIgnoreTracedInputEvent(event.eventType)) { return; } - const TraceLevel traceLevel = dataSource->resolveTraceLevel(args); + const TraceLevel traceLevel = dataSource->resolveTraceLevel(metadata); if (traceLevel == TraceLevel::TRACE_LEVEL_NONE) { return; } @@ -207,14 +208,14 @@ void PerfettoBackend::traceKeyEvent(const TracedKeyEvent& event, const TracedEve } void PerfettoBackend::traceWindowDispatch(const WindowDispatchArgs& dispatchArgs, - const TracedEventArgs& args) { + const TracedEventMetadata& metadata) { InputEventDataSource::Trace([&](InputEventDataSource::TraceContext ctx) { auto dataSource = ctx.GetDataSourceLocked(); dataSource->initializeUidMap(mGetPackageUid); if (!dataSource->getFlags().test(TraceFlag::TRACE_DISPATCHER_WINDOW_DISPATCH)) { return; } - const TraceLevel traceLevel = dataSource->resolveTraceLevel(args); + const TraceLevel traceLevel = dataSource->resolveTraceLevel(metadata); if (traceLevel == TraceLevel::TRACE_LEVEL_NONE) { return; } diff --git a/services/inputflinger/dispatcher/trace/InputTracingPerfettoBackend.h b/services/inputflinger/dispatcher/trace/InputTracingPerfettoBackend.h index af1c6b72e3..e945066dff 100644 --- a/services/inputflinger/dispatcher/trace/InputTracingPerfettoBackend.h +++ b/services/inputflinger/dispatcher/trace/InputTracingPerfettoBackend.h @@ -54,9 +54,9 @@ public: explicit PerfettoBackend(GetPackageUid); ~PerfettoBackend() override = default; - void traceKeyEvent(const TracedKeyEvent&, const TracedEventArgs&) override; - void traceMotionEvent(const TracedMotionEvent&, const TracedEventArgs&) override; - void traceWindowDispatch(const WindowDispatchArgs&, const TracedEventArgs&) override; + void traceKeyEvent(const TracedKeyEvent&, const TracedEventMetadata&) override; + void traceMotionEvent(const TracedMotionEvent&, const TracedEventMetadata&) override; + void traceWindowDispatch(const WindowDispatchArgs&, const TracedEventMetadata&) override; private: // Implementation of the perfetto data source. @@ -72,13 +72,13 @@ private: void initializeUidMap(GetPackageUid); bool shouldIgnoreTracedInputEvent(const EventType&) const; inline ftl::Flags getFlags() const { return mConfig.flags; } - TraceLevel resolveTraceLevel(const TracedEventArgs&) const; + TraceLevel resolveTraceLevel(const TracedEventMetadata&) const; private: const int32_t mInstanceId; TraceConfig mConfig; - bool ruleMatches(const TraceRule&, const TracedEventArgs&) const; + bool ruleMatches(const TraceRule&, const TracedEventMetadata&) const; std::optional> mUidMap; }; diff --git a/services/inputflinger/dispatcher/trace/ThreadedBackend.cpp b/services/inputflinger/dispatcher/trace/ThreadedBackend.cpp index b1791b3268..7e13047b61 100644 --- a/services/inputflinger/dispatcher/trace/ThreadedBackend.cpp +++ b/services/inputflinger/dispatcher/trace/ThreadedBackend.cpp @@ -54,25 +54,25 @@ ThreadedBackend::~ThreadedBackend() { template void ThreadedBackend::traceMotionEvent(const TracedMotionEvent& event, - const TracedEventArgs& traceArgs) { + const TracedEventMetadata& metadata) { std::scoped_lock lock(mLock); - mQueue.emplace_back(event, traceArgs); + mQueue.emplace_back(event, metadata); mThreadWakeCondition.notify_all(); } template void ThreadedBackend::traceKeyEvent(const TracedKeyEvent& event, - const TracedEventArgs& traceArgs) { + const TracedEventMetadata& metadata) { std::scoped_lock lock(mLock); - mQueue.emplace_back(event, traceArgs); + mQueue.emplace_back(event, metadata); mThreadWakeCondition.notify_all(); } template void ThreadedBackend::traceWindowDispatch(const WindowDispatchArgs& dispatchArgs, - const TracedEventArgs& traceArgs) { + const TracedEventMetadata& metadata) { std::scoped_lock lock(mLock); - mQueue.emplace_back(dispatchArgs, traceArgs); + mQueue.emplace_back(dispatchArgs, metadata); mThreadWakeCondition.notify_all(); } diff --git a/services/inputflinger/dispatcher/trace/ThreadedBackend.h b/services/inputflinger/dispatcher/trace/ThreadedBackend.h index cab47af1c1..f4659a83a8 100644 --- a/services/inputflinger/dispatcher/trace/ThreadedBackend.h +++ b/services/inputflinger/dispatcher/trace/ThreadedBackend.h @@ -38,9 +38,9 @@ public: ThreadedBackend(Backend&& innerBackend); ~ThreadedBackend() override; - void traceKeyEvent(const TracedKeyEvent&, const TracedEventArgs&) override; - void traceMotionEvent(const TracedMotionEvent&, const TracedEventArgs&) override; - void traceWindowDispatch(const WindowDispatchArgs&, const TracedEventArgs&) override; + void traceKeyEvent(const TracedKeyEvent&, const TracedEventMetadata&) override; + void traceMotionEvent(const TracedMotionEvent&, const TracedEventMetadata&) override; + void traceWindowDispatch(const WindowDispatchArgs&, const TracedEventMetadata&) override; private: std::mutex mLock; @@ -50,7 +50,7 @@ private: Backend mBackend; using TraceEntry = std::pair, - TracedEventArgs>; + TracedEventMetadata>; std::vector mQueue GUARDED_BY(mLock); void threadLoop(); diff --git a/services/inputflinger/tests/FakeInputTracingBackend.cpp b/services/inputflinger/tests/FakeInputTracingBackend.cpp index 069b50d051..b46055ed1c 100644 --- a/services/inputflinger/tests/FakeInputTracingBackend.cpp +++ b/services/inputflinger/tests/FakeInputTracingBackend.cpp @@ -162,7 +162,7 @@ base::Result VerifyingTrace::verifyEventTraced(const Event& expectedEvent, // --- FakeInputTracingBackend --- void FakeInputTracingBackend::traceKeyEvent(const trace::TracedKeyEvent& event, - const trace::TracedEventArgs&) { + const trace::TracedEventMetadata&) { { std::scoped_lock lock(mTrace->mLock); mTrace->mTracedEvents.emplace(event.id, event); @@ -171,7 +171,7 @@ void FakeInputTracingBackend::traceKeyEvent(const trace::TracedKeyEvent& event, } void FakeInputTracingBackend::traceMotionEvent(const trace::TracedMotionEvent& event, - const trace::TracedEventArgs&) { + const trace::TracedEventMetadata&) { { std::scoped_lock lock(mTrace->mLock); mTrace->mTracedEvents.emplace(event.id, event); @@ -180,7 +180,7 @@ void FakeInputTracingBackend::traceMotionEvent(const trace::TracedMotionEvent& e } void FakeInputTracingBackend::traceWindowDispatch(const trace::WindowDispatchArgs& args, - const trace::TracedEventArgs&) { + const trace::TracedEventMetadata&) { { std::scoped_lock lock(mTrace->mLock); mTrace->mTracedWindowDispatches.push_back(args); diff --git a/services/inputflinger/tests/FakeInputTracingBackend.h b/services/inputflinger/tests/FakeInputTracingBackend.h index ab05d6b532..cd4b507384 100644 --- a/services/inputflinger/tests/FakeInputTracingBackend.h +++ b/services/inputflinger/tests/FakeInputTracingBackend.h @@ -82,11 +82,12 @@ public: private: std::shared_ptr mTrace; - void traceKeyEvent(const trace::TracedKeyEvent& entry, const trace::TracedEventArgs&) override; + void traceKeyEvent(const trace::TracedKeyEvent& entry, + const trace::TracedEventMetadata&) override; void traceMotionEvent(const trace::TracedMotionEvent& entry, - const trace::TracedEventArgs&) override; + const trace::TracedEventMetadata&) override; void traceWindowDispatch(const trace::WindowDispatchArgs& entry, - const trace::TracedEventArgs&) override; + const trace::TracedEventMetadata&) override; }; } // namespace android::inputdispatcher -- cgit v1.2.3-59-g8ed1b From 04a664297d32d0e6d8161d942a131a0efcca2443 Mon Sep 17 00:00:00 2001 From: Prabir Pradhan Date: Fri, 15 Mar 2024 22:45:27 +0000 Subject: InputTracer: Adjust sensitivity based on IME connection Based on the trace rules, we can adjust the trace level depending on when there was an active IME connection when the event processing was complete. Bug: 210460522 Test: manual with perfetto Change-Id: I90587c3004fa05517cf44c4c0b6b5c5c40fc00d1 --- .../inputflinger/dispatcher/InputDispatcher.cpp | 7 ++++++ services/inputflinger/dispatcher/InputDispatcher.h | 2 ++ .../dispatcher/include/InputDispatcherInterface.h | 5 ++++ .../inputflinger/dispatcher/trace/InputTracer.cpp | 29 ++++++++++++++++------ .../inputflinger/dispatcher/trace/InputTracer.h | 5 ++++ .../dispatcher/trace/InputTracerInterface.h | 5 ++++ .../trace/InputTracingBackendInterface.h | 2 ++ .../trace/InputTracingPerfettoBackend.cpp | 6 +++++ 8 files changed, 54 insertions(+), 7 deletions(-) (limited to 'services') diff --git a/services/inputflinger/dispatcher/InputDispatcher.cpp b/services/inputflinger/dispatcher/InputDispatcher.cpp index 065c5c873c..d857723649 100644 --- a/services/inputflinger/dispatcher/InputDispatcher.cpp +++ b/services/inputflinger/dispatcher/InputDispatcher.cpp @@ -7144,4 +7144,11 @@ bool InputDispatcher::isPointerInWindow(const sp& token, int32 return false; } +void InputDispatcher::setInputMethodConnectionIsActive(bool isActive) { + std::scoped_lock _l(mLock); + if (mTracer) { + mTracer->setInputMethodConnectionIsActive(isActive); + } +} + } // namespace android::inputdispatcher diff --git a/services/inputflinger/dispatcher/InputDispatcher.h b/services/inputflinger/dispatcher/InputDispatcher.h index 13571b3b5f..f884685e19 100644 --- a/services/inputflinger/dispatcher/InputDispatcher.h +++ b/services/inputflinger/dispatcher/InputDispatcher.h @@ -158,6 +158,8 @@ public: bool isPointerInWindow(const sp& token, int32_t displayId, DeviceId deviceId, int32_t pointerId) override; + void setInputMethodConnectionIsActive(bool isActive) override; + private: enum class DropReason { NOT_DROPPED, diff --git a/services/inputflinger/dispatcher/include/InputDispatcherInterface.h b/services/inputflinger/dispatcher/include/InputDispatcherInterface.h index 7c440e8218..6b9262cfa3 100644 --- a/services/inputflinger/dispatcher/include/InputDispatcherInterface.h +++ b/services/inputflinger/dispatcher/include/InputDispatcherInterface.h @@ -236,6 +236,11 @@ public: */ virtual bool isPointerInWindow(const sp& token, int32_t displayId, DeviceId deviceId, int32_t pointerId) = 0; + + /* + * Notify the dispatcher that the state of the input method connection changed. + */ + virtual void setInputMethodConnectionIsActive(bool isActive) = 0; }; } // namespace android diff --git a/services/inputflinger/dispatcher/trace/InputTracer.cpp b/services/inputflinger/dispatcher/trace/InputTracer.cpp index 019283f133..32fa740565 100644 --- a/services/inputflinger/dispatcher/trace/InputTracer.cpp +++ b/services/inputflinger/dispatcher/trace/InputTracer.cpp @@ -141,7 +141,6 @@ void InputTracer::dispatchToTargetHint(const EventTrackerInterface& cookie, eventState->targets.emplace(targetInfo.uid); eventState->isSecure |= targetInfo.isSecureWindow; - // TODO(b/210460522): Set events as sensitive when the IME connection is active. } void InputTracer::eventProcessingComplete(const EventTrackerInterface& cookie) { @@ -177,8 +176,11 @@ std::unique_ptr InputTracer::traceDerivedEvent( // is dispatched, such as in the case of key fallback events. To account for these cases, // derived events can be traced after the processing is complete for the original event. const auto& event = eventState->events.back(); - const TracedEventMetadata metadata{.isSecure = eventState->isSecure, - .targets = eventState->targets}; + const TracedEventMetadata metadata{ + .isSecure = eventState->isSecure, + .targets = eventState->targets, + .isImeConnectionActive = eventState->isImeConnectionActive, + }; writeEventToBackend(event, std::move(metadata), *mBackend); } return std::make_unique(std::move(eventState), /*isDerived=*/true); @@ -226,8 +228,11 @@ void InputTracer::traceEventDispatch(const DispatchEntry& dispatchEntry, /*hmac=*/{}, resolvedKeyRepeatCount}; if (eventState->isEventProcessingComplete) { - const TracedEventMetadata metadata{.isSecure = eventState->isSecure, - .targets = eventState->targets}; + const TracedEventMetadata metadata{ + .isSecure = eventState->isSecure, + .targets = eventState->targets, + .isImeConnectionActive = eventState->isImeConnectionActive, + }; mBackend->traceWindowDispatch(std::move(windowDispatchArgs), std::move(metadata)); } else { eventState->pendingDispatchArgs.emplace_back(std::move(windowDispatchArgs)); @@ -246,9 +251,15 @@ bool InputTracer::isDerivedCookie(const EventTrackerInterface& cookie) { // --- InputTracer::EventState --- void InputTracer::EventState::onEventProcessingComplete() { + isImeConnectionActive = tracer.mIsImeConnectionActive; + // Write all of the events known so far to the trace. for (const auto& event : events) { - const TracedEventMetadata metadata{.isSecure = isSecure, .targets = targets}; + const TracedEventMetadata metadata{ + .isSecure = isSecure, + .targets = targets, + .isImeConnectionActive = isImeConnectionActive, + }; writeEventToBackend(event, std::move(metadata), *tracer.mBackend); } // Write all pending dispatch args to the trace. @@ -263,7 +274,11 @@ void InputTracer::EventState::onEventProcessingComplete() { << ": Failed to find a previously traced event that matches the dispatched " "event"; } - const TracedEventMetadata metadata{.isSecure = isSecure, .targets = targets}; + const TracedEventMetadata metadata{ + .isSecure = isSecure, + .targets = targets, + .isImeConnectionActive = isImeConnectionActive, + }; tracer.mBackend->traceWindowDispatch(windowDispatchArgs, std::move(metadata)); } pendingDispatchArgs.clear(); diff --git a/services/inputflinger/dispatcher/trace/InputTracer.h b/services/inputflinger/dispatcher/trace/InputTracer.h index 717bc1f1a8..dfaf7c3146 100644 --- a/services/inputflinger/dispatcher/trace/InputTracer.h +++ b/services/inputflinger/dispatcher/trace/InputTracer.h @@ -48,9 +48,13 @@ public: std::unique_ptr traceDerivedEvent(const EventEntry&, const EventTrackerInterface&) override; void traceEventDispatch(const DispatchEntry&, const EventTrackerInterface&) override; + void setInputMethodConnectionIsActive(bool isActive) override { + mIsImeConnectionActive = isActive; + } private: std::unique_ptr mBackend; + bool mIsImeConnectionActive{false}; // The state of a tracked event, shared across all events derived from the original event. struct EventState { @@ -68,6 +72,7 @@ private: bool isSecure{false}; // The list of all possible UIDs that this event could be targeting. std::set targets; + bool isImeConnectionActive{false}; }; // Get the event state associated with a tracking cookie. diff --git a/services/inputflinger/dispatcher/trace/InputTracerInterface.h b/services/inputflinger/dispatcher/trace/InputTracerInterface.h index 609d10c0f7..af6eefb1db 100644 --- a/services/inputflinger/dispatcher/trace/InputTracerInterface.h +++ b/services/inputflinger/dispatcher/trace/InputTracerInterface.h @@ -103,6 +103,11 @@ public: * provided. */ virtual void traceEventDispatch(const DispatchEntry&, const EventTrackerInterface&) = 0; + + /** + * Notify that the state of the input method connection changed. + */ + virtual void setInputMethodConnectionIsActive(bool isActive) = 0; }; } // namespace android::inputdispatcher::trace diff --git a/services/inputflinger/dispatcher/trace/InputTracingBackendInterface.h b/services/inputflinger/dispatcher/trace/InputTracingBackendInterface.h index bc037b39e4..2b45e3ae1c 100644 --- a/services/inputflinger/dispatcher/trace/InputTracingBackendInterface.h +++ b/services/inputflinger/dispatcher/trace/InputTracingBackendInterface.h @@ -97,6 +97,8 @@ struct TracedEventMetadata { bool isSecure; // The list of possible UIDs that this event could be targeting. std::set targets; + // True if the there was an active input method connection while this event was processed. + bool isImeConnectionActive; }; /** Additional information about an input event being dispatched to a window. */ diff --git a/services/inputflinger/dispatcher/trace/InputTracingPerfettoBackend.cpp b/services/inputflinger/dispatcher/trace/InputTracingPerfettoBackend.cpp index b413def815..9c39743569 100644 --- a/services/inputflinger/dispatcher/trace/InputTracingPerfettoBackend.cpp +++ b/services/inputflinger/dispatcher/trace/InputTracingPerfettoBackend.cpp @@ -118,6 +118,12 @@ bool PerfettoBackend::InputEventDataSource::ruleMatches(const TraceRule& rule, return false; } + // Match the event if it was processed while there was an active InputMethod connection. + if (rule.matchImeConnectionActive.has_value() && + *rule.matchImeConnectionActive != metadata.isImeConnectionActive) { + return false; + } + // Match the event if all of its target packages are explicitly allowed in the "match all" list. if (!rule.matchAllPackages.empty() && !std::all_of(metadata.targets.begin(), metadata.targets.end(), [&](const auto& uid) { -- cgit v1.2.3-59-g8ed1b