blob: 32fa740565b68b3392413723efaf934c46f58fac [file] [log] [blame]
Prabir Pradhandae52792023-12-15 07:36:40 +00001/*
2 * Copyright 2024 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "InputTracer"
18
19#include "InputTracer.h"
20
21#include <android-base/logging.h>
Prabir Pradhanbf3c8322024-02-23 02:38:36 +000022#include <private/android_filesystem_config.h>
Prabir Pradhandae52792023-12-15 07:36:40 +000023
24namespace android::inputdispatcher::trace::impl {
25
26namespace {
27
Prabir Pradhanbb7a0202024-02-10 02:09:01 +000028// Helper to std::visit with lambdas.
29template <typename... V>
30struct Visitor : V... {
31 using V::operator()...;
32};
33
Prabir Pradhan4c49aad2024-02-08 20:42:35 +000034TracedEvent createTracedEvent(const MotionEntry& e, EventType type) {
Prabir Pradhandae52792023-12-15 07:36:40 +000035 return TracedMotionEvent{e.id,
36 e.eventTime,
37 e.policyFlags,
38 e.deviceId,
39 e.source,
40 e.displayId,
41 e.action,
42 e.actionButton,
43 e.flags,
44 e.metaState,
45 e.buttonState,
46 e.classification,
47 e.edgeFlags,
48 e.xPrecision,
49 e.yPrecision,
50 e.xCursorPosition,
51 e.yCursorPosition,
52 e.downTime,
53 e.pointerProperties,
Prabir Pradhan4c49aad2024-02-08 20:42:35 +000054 e.pointerCoords,
55 type};
Prabir Pradhandae52792023-12-15 07:36:40 +000056}
57
Prabir Pradhan4c49aad2024-02-08 20:42:35 +000058TracedEvent createTracedEvent(const KeyEntry& e, EventType type) {
Prabir Pradhandae52792023-12-15 07:36:40 +000059 return TracedKeyEvent{e.id, e.eventTime, e.policyFlags, e.deviceId, e.source,
60 e.displayId, e.action, e.keyCode, e.scanCode, e.metaState,
Prabir Pradhan4c49aad2024-02-08 20:42:35 +000061 e.downTime, e.flags, e.repeatCount, type};
Prabir Pradhandae52792023-12-15 07:36:40 +000062}
63
Prabir Pradhanc7edaaa2024-03-15 15:31:02 +000064void writeEventToBackend(const TracedEvent& event, const TracedEventMetadata metadata,
Prabir Pradhan8c3b1432024-02-09 23:34:16 +000065 InputTracingBackendInterface& backend) {
Prabir Pradhanc7edaaa2024-03-15 15:31:02 +000066 std::visit(Visitor{[&](const TracedMotionEvent& e) { backend.traceMotionEvent(e, metadata); },
67 [&](const TracedKeyEvent& e) { backend.traceKeyEvent(e, metadata); }},
Prabir Pradhana67623c2024-02-21 06:57:36 +000068 event);
69}
70
Prabir Pradhand6b2b052024-02-21 23:25:15 +000071inline auto getId(const trace::TracedEvent& v) {
72 return std::visit([](const auto& event) { return event.id; }, v);
73}
74
Prabir Pradhanbf3c8322024-02-23 02:38:36 +000075// Helper class to extract relevant information from InputTarget.
76struct InputTargetInfo {
77 gui::Uid uid;
78 bool isSecureWindow;
79};
80
81InputTargetInfo getTargetInfo(const InputTarget& target) {
82 if (target.windowHandle == nullptr) {
83 if (!target.connection->monitor) {
84 LOG(FATAL) << __func__ << ": Window is not set for non-monitor target";
85 }
86 // This is a global monitor, assume its target is the system.
87 return {.uid = gui::Uid{AID_SYSTEM}, .isSecureWindow = false};
88 }
89 return {target.windowHandle->getInfo()->ownerUid,
90 target.windowHandle->getInfo()->layoutParamsFlags.test(gui::WindowInfo::Flag::SECURE)};
91}
92
Prabir Pradhandae52792023-12-15 07:36:40 +000093} // namespace
94
95// --- InputTracer ---
96
97InputTracer::InputTracer(std::unique_ptr<InputTracingBackendInterface> backend)
Prabir Pradhanbb7a0202024-02-10 02:09:01 +000098 : mBackend(std::move(backend)) {}
Prabir Pradhandae52792023-12-15 07:36:40 +000099
100std::unique_ptr<EventTrackerInterface> InputTracer::traceInboundEvent(const EventEntry& entry) {
Prabir Pradhana67623c2024-02-21 06:57:36 +0000101 // This is a newly traced inbound event. Create a new state to track it and its derived events.
102 auto eventState = std::make_shared<EventState>(*this);
Prabir Pradhandae52792023-12-15 07:36:40 +0000103
104 if (entry.type == EventEntry::Type::MOTION) {
105 const auto& motion = static_cast<const MotionEntry&>(entry);
Prabir Pradhan4c49aad2024-02-08 20:42:35 +0000106 eventState->events.emplace_back(createTracedEvent(motion, EventType::INBOUND));
Prabir Pradhandae52792023-12-15 07:36:40 +0000107 } else if (entry.type == EventEntry::Type::KEY) {
108 const auto& key = static_cast<const KeyEntry&>(entry);
Prabir Pradhan4c49aad2024-02-08 20:42:35 +0000109 eventState->events.emplace_back(createTracedEvent(key, EventType::INBOUND));
Prabir Pradhandae52792023-12-15 07:36:40 +0000110 } else {
111 LOG(FATAL) << "Cannot trace EventEntry of type: " << ftl::enum_string(entry.type);
112 }
113
Prabir Pradhana67623c2024-02-21 06:57:36 +0000114 return std::make_unique<EventTrackerImpl>(std::move(eventState), /*isDerived=*/false);
Prabir Pradhandae52792023-12-15 07:36:40 +0000115}
116
Prabir Pradhand6b2b052024-02-21 23:25:15 +0000117std::unique_ptr<EventTrackerInterface> InputTracer::createTrackerForSyntheticEvent() {
118 // Create a new EventState to track events derived from this tracker.
119 return std::make_unique<EventTrackerImpl>(std::make_shared<EventState>(*this),
120 /*isDerived=*/false);
121}
122
Prabir Pradhandae52792023-12-15 07:36:40 +0000123void InputTracer::dispatchToTargetHint(const EventTrackerInterface& cookie,
124 const InputTarget& target) {
Prabir Pradhan1ea04a32024-02-10 03:02:59 +0000125 auto& eventState = getState(cookie);
Prabir Pradhanbf3c8322024-02-23 02:38:36 +0000126 const InputTargetInfo& targetInfo = getTargetInfo(target);
Prabir Pradhana67623c2024-02-21 06:57:36 +0000127 if (eventState->isEventProcessingComplete) {
Prabir Pradhanbf3c8322024-02-23 02:38:36 +0000128 // Disallow adding new targets after eventProcessingComplete() is called.
129 if (eventState->targets.find(targetInfo.uid) == eventState->targets.end()) {
130 LOG(FATAL) << __func__ << ": Cannot add new target after eventProcessingComplete";
131 }
Prabir Pradhana67623c2024-02-21 06:57:36 +0000132 return;
Prabir Pradhandae52792023-12-15 07:36:40 +0000133 }
Prabir Pradhanb95d4aa2024-03-11 22:48:04 +0000134 if (isDerivedCookie(cookie)) {
Prabir Pradhanbf3c8322024-02-23 02:38:36 +0000135 // Disallow adding new targets from a derived cookie.
136 if (eventState->targets.find(targetInfo.uid) == eventState->targets.end()) {
137 LOG(FATAL) << __func__ << ": Cannot add new target from a derived cookie";
138 }
Prabir Pradhanb95d4aa2024-03-11 22:48:04 +0000139 return;
140 }
Prabir Pradhanbf3c8322024-02-23 02:38:36 +0000141
142 eventState->targets.emplace(targetInfo.uid);
143 eventState->isSecure |= targetInfo.isSecureWindow;
Prabir Pradhandae52792023-12-15 07:36:40 +0000144}
145
146void InputTracer::eventProcessingComplete(const EventTrackerInterface& cookie) {
Prabir Pradhana67623c2024-02-21 06:57:36 +0000147 if (isDerivedCookie(cookie)) {
148 LOG(FATAL) << "Event processing cannot be set from a derived cookie.";
149 }
Prabir Pradhan1ea04a32024-02-10 03:02:59 +0000150 auto& eventState = getState(cookie);
Prabir Pradhana67623c2024-02-21 06:57:36 +0000151 if (eventState->isEventProcessingComplete) {
Prabir Pradhanbb7a0202024-02-10 02:09:01 +0000152 LOG(FATAL) << "Traced event was already logged. "
153 "eventProcessingComplete() was likely called more than once.";
154 }
Prabir Pradhane7701642024-02-22 04:06:53 +0000155 eventState->onEventProcessingComplete();
Prabir Pradhana67623c2024-02-21 06:57:36 +0000156}
157
158std::unique_ptr<EventTrackerInterface> InputTracer::traceDerivedEvent(
159 const EventEntry& entry, const EventTrackerInterface& originalEventCookie) {
160 // This is an event derived from an already-established event. Use the same state to track
161 // this event too.
162 auto eventState = getState(originalEventCookie);
163
164 if (entry.type == EventEntry::Type::MOTION) {
165 const auto& motion = static_cast<const MotionEntry&>(entry);
Prabir Pradhan4c49aad2024-02-08 20:42:35 +0000166 eventState->events.emplace_back(createTracedEvent(motion, EventType::SYNTHESIZED));
Prabir Pradhana67623c2024-02-21 06:57:36 +0000167 } else if (entry.type == EventEntry::Type::KEY) {
168 const auto& key = static_cast<const KeyEntry&>(entry);
Prabir Pradhan4c49aad2024-02-08 20:42:35 +0000169 eventState->events.emplace_back(createTracedEvent(key, EventType::SYNTHESIZED));
Prabir Pradhana67623c2024-02-21 06:57:36 +0000170 } else {
171 LOG(FATAL) << "Cannot trace EventEntry of type: " << ftl::enum_string(entry.type);
172 }
173
174 if (eventState->isEventProcessingComplete) {
175 // It is possible for a derived event to be dispatched some time after the original event
176 // is dispatched, such as in the case of key fallback events. To account for these cases,
177 // derived events can be traced after the processing is complete for the original event.
Prabir Pradhan4c49aad2024-02-08 20:42:35 +0000178 const auto& event = eventState->events.back();
Prabir Pradhan04a66422024-03-15 22:45:27 +0000179 const TracedEventMetadata metadata{
180 .isSecure = eventState->isSecure,
181 .targets = eventState->targets,
182 .isImeConnectionActive = eventState->isImeConnectionActive,
183 };
Prabir Pradhanc7edaaa2024-03-15 15:31:02 +0000184 writeEventToBackend(event, std::move(metadata), *mBackend);
Prabir Pradhana67623c2024-02-21 06:57:36 +0000185 }
186 return std::make_unique<EventTrackerImpl>(std::move(eventState), /*isDerived=*/true);
Prabir Pradhandae52792023-12-15 07:36:40 +0000187}
188
189void InputTracer::traceEventDispatch(const DispatchEntry& dispatchEntry,
Prabir Pradhand6b2b052024-02-21 23:25:15 +0000190 const EventTrackerInterface& cookie) {
191 auto& eventState = getState(cookie);
Prabir Pradhanbb7a0202024-02-10 02:09:01 +0000192 const EventEntry& entry = *dispatchEntry.eventEntry;
Prabir Pradhan4c49aad2024-02-08 20:42:35 +0000193 const int32_t eventId = entry.id;
Prabir Pradhan560d0d12024-03-07 18:08:27 +0000194 // TODO(b/328618922): Remove resolved key repeats after making repeatCount non-mutable.
195 // The KeyEntry's repeatCount is mutable and can be modified after an event is initially traced,
196 // so we need to find the repeatCount at the time of dispatching to trace it accurately.
197 int32_t resolvedKeyRepeatCount = 0;
Prabir Pradhan4c49aad2024-02-08 20:42:35 +0000198 if (entry.type == EventEntry::Type::KEY) {
199 resolvedKeyRepeatCount = static_cast<const KeyEntry&>(entry).repeatCount;
Prabir Pradhanbb7a0202024-02-10 02:09:01 +0000200 }
Prabir Pradhanadc59b42023-12-15 05:34:11 +0000201
Prabir Pradhand6b2b052024-02-21 23:25:15 +0000202 auto tracedEventIt =
203 std::find_if(eventState->events.begin(), eventState->events.end(),
Prabir Pradhan4c49aad2024-02-08 20:42:35 +0000204 [eventId](const auto& event) { return eventId == getId(event); });
Prabir Pradhand6b2b052024-02-21 23:25:15 +0000205 if (tracedEventIt == eventState->events.end()) {
206 LOG(FATAL)
207 << __func__
208 << ": Failed to find a previously traced event that matches the dispatched event";
Prabir Pradhanbb7a0202024-02-10 02:09:01 +0000209 }
Prabir Pradhanadc59b42023-12-15 05:34:11 +0000210
Prabir Pradhanbf3c8322024-02-23 02:38:36 +0000211 if (eventState->targets.count(dispatchEntry.targetUid) == 0) {
212 LOG(FATAL) << __func__ << ": Event is being dispatched to UID that it is not targeting";
213 }
214
Prabir Pradhanbb7a0202024-02-10 02:09:01 +0000215 // The vsyncId only has meaning if the event is targeting a window.
216 const int32_t windowId = dispatchEntry.windowId.value_or(0);
217 const int32_t vsyncId = dispatchEntry.windowId.has_value() ? dispatchEntry.vsyncId : 0;
Prabir Pradhanadc59b42023-12-15 05:34:11 +0000218
Prabir Pradhan8c3b1432024-02-09 23:34:16 +0000219 // TODO(b/210460522): Pass HMAC into traceEventDispatch.
Prabir Pradhan4c49aad2024-02-08 20:42:35 +0000220 const WindowDispatchArgs windowDispatchArgs{*tracedEventIt,
Prabir Pradhan52ec3ff2024-02-22 03:26:38 +0000221 dispatchEntry.deliveryTime,
222 dispatchEntry.resolvedFlags,
223 dispatchEntry.targetUid,
224 vsyncId,
225 windowId,
226 dispatchEntry.transform,
227 dispatchEntry.rawTransform,
228 /*hmac=*/{},
229 resolvedKeyRepeatCount};
230 if (eventState->isEventProcessingComplete) {
Prabir Pradhan04a66422024-03-15 22:45:27 +0000231 const TracedEventMetadata metadata{
232 .isSecure = eventState->isSecure,
233 .targets = eventState->targets,
234 .isImeConnectionActive = eventState->isImeConnectionActive,
235 };
Prabir Pradhanc7edaaa2024-03-15 15:31:02 +0000236 mBackend->traceWindowDispatch(std::move(windowDispatchArgs), std::move(metadata));
Prabir Pradhan52ec3ff2024-02-22 03:26:38 +0000237 } else {
238 eventState->pendingDispatchArgs.emplace_back(std::move(windowDispatchArgs));
239 }
Prabir Pradhanadc59b42023-12-15 05:34:11 +0000240}
Prabir Pradhandae52792023-12-15 07:36:40 +0000241
Prabir Pradhana67623c2024-02-21 06:57:36 +0000242std::shared_ptr<InputTracer::EventState>& InputTracer::getState(
243 const EventTrackerInterface& cookie) {
Prabir Pradhanbb7a0202024-02-10 02:09:01 +0000244 return static_cast<const EventTrackerImpl&>(cookie).mState;
Prabir Pradhandae52792023-12-15 07:36:40 +0000245}
246
Prabir Pradhana67623c2024-02-21 06:57:36 +0000247bool InputTracer::isDerivedCookie(const EventTrackerInterface& cookie) {
248 return static_cast<const EventTrackerImpl&>(cookie).mIsDerived;
249}
Prabir Pradhandae52792023-12-15 07:36:40 +0000250
Prabir Pradhana67623c2024-02-21 06:57:36 +0000251// --- InputTracer::EventState ---
Prabir Pradhandae52792023-12-15 07:36:40 +0000252
Prabir Pradhane7701642024-02-22 04:06:53 +0000253void InputTracer::EventState::onEventProcessingComplete() {
Prabir Pradhan04a66422024-03-15 22:45:27 +0000254 isImeConnectionActive = tracer.mIsImeConnectionActive;
255
Prabir Pradhane7701642024-02-22 04:06:53 +0000256 // Write all of the events known so far to the trace.
257 for (const auto& event : events) {
Prabir Pradhan04a66422024-03-15 22:45:27 +0000258 const TracedEventMetadata metadata{
259 .isSecure = isSecure,
260 .targets = targets,
261 .isImeConnectionActive = isImeConnectionActive,
262 };
Prabir Pradhanc7edaaa2024-03-15 15:31:02 +0000263 writeEventToBackend(event, std::move(metadata), *tracer.mBackend);
Prabir Pradhane7701642024-02-22 04:06:53 +0000264 }
Prabir Pradhan52ec3ff2024-02-22 03:26:38 +0000265 // Write all pending dispatch args to the trace.
266 for (const auto& windowDispatchArgs : pendingDispatchArgs) {
Prabir Pradhan4c49aad2024-02-08 20:42:35 +0000267 auto tracedEventIt =
268 std::find_if(events.begin(), events.end(),
269 [id = getId(windowDispatchArgs.eventEntry)](const auto& event) {
270 return id == getId(event);
271 });
272 if (tracedEventIt == events.end()) {
273 LOG(FATAL) << __func__
274 << ": Failed to find a previously traced event that matches the dispatched "
275 "event";
276 }
Prabir Pradhan04a66422024-03-15 22:45:27 +0000277 const TracedEventMetadata metadata{
278 .isSecure = isSecure,
279 .targets = targets,
280 .isImeConnectionActive = isImeConnectionActive,
281 };
Prabir Pradhanc7edaaa2024-03-15 15:31:02 +0000282 tracer.mBackend->traceWindowDispatch(windowDispatchArgs, std::move(metadata));
Prabir Pradhan52ec3ff2024-02-22 03:26:38 +0000283 }
284 pendingDispatchArgs.clear();
285
Prabir Pradhane7701642024-02-22 04:06:53 +0000286 isEventProcessingComplete = true;
287}
288
Prabir Pradhana67623c2024-02-21 06:57:36 +0000289InputTracer::EventState::~EventState() {
290 if (isEventProcessingComplete) {
Prabir Pradhanbb7a0202024-02-10 02:09:01 +0000291 // This event has already been written to the trace as expected.
292 return;
293 }
Prabir Pradhan1ea04a32024-02-10 03:02:59 +0000294 // The event processing was never marked as complete, so do it now.
Prabir Pradhane7701642024-02-22 04:06:53 +0000295 // We should never end up here in normal operation. However, in tests, it's possible that we
296 // stop and destroy InputDispatcher without waiting for it to finish processing events, at
297 // which point an event (and thus its EventState) may be destroyed before processing finishes.
298 onEventProcessingComplete();
Prabir Pradhandae52792023-12-15 07:36:40 +0000299}
300
301} // namespace android::inputdispatcher::trace::impl