1 /*
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 #pragma once
18 
19 #include <gui/PidUid.h>
20 #include <input/Input.h>
21 #include <ui/Transform.h>
22 
23 #include <array>
24 #include <set>
25 #include <variant>
26 #include <vector>
27 
28 namespace android::inputdispatcher::trace {
29 
30 /**
31  * Describes the type of this event being traced, with respect to InputDispatcher.
32  */
33 enum class EventType {
34     // This is an event that was reported through the InputListener interface or was injected.
35     INBOUND,
36     // This is an event that was synthesized within InputDispatcher; either being derived
37     // from an inbound event (e.g. a split motion event), or synthesized completely
38     // (e.g. a CANCEL event generated when the inbound stream is not canceled).
39     SYNTHESIZED,
40 
41     ftl_last = SYNTHESIZED,
42 };
43 
44 /**
45  * A representation of an Android KeyEvent used by the tracing backend.
46  */
47 struct TracedKeyEvent {
48     int32_t id;
49     nsecs_t eventTime;
50     uint32_t policyFlags;
51     int32_t deviceId;
52     uint32_t source;
53     ui::LogicalDisplayId displayId;
54     int32_t action;
55     int32_t keyCode;
56     int32_t scanCode;
57     int32_t metaState;
58     nsecs_t downTime;
59     int32_t flags;
60     int32_t repeatCount;
61     EventType eventType;
62 };
63 
64 /**
65  * A representation of an Android MotionEvent used by the tracing backend.
66  */
67 struct TracedMotionEvent {
68     int32_t id;
69     nsecs_t eventTime;
70     uint32_t policyFlags;
71     int32_t deviceId;
72     uint32_t source;
73     ui::LogicalDisplayId displayId;
74     int32_t action;
75     int32_t actionButton;
76     int32_t flags;
77     int32_t metaState;
78     int32_t buttonState;
79     MotionClassification classification;
80     int32_t edgeFlags;
81     float xPrecision;
82     float yPrecision;
83     float xCursorPosition;
84     float yCursorPosition;
85     nsecs_t downTime;
86     std::vector<PointerProperties> pointerProperties;
87     std::vector<PointerCoords> pointerCoords;
88     EventType eventType;
89 };
90 
91 /** A representation of a traced input event. */
92 using TracedEvent = std::variant<TracedKeyEvent, TracedMotionEvent>;
93 
94 /** Additional information about an input event being traced. */
95 struct TracedEventMetadata {
96     // True if the event is targeting at least one secure window.
97     bool isSecure;
98     // The list of possible UIDs that this event could be targeting.
99     std::set<gui::Uid> targets;
100     // True if the there was an active input method connection while this event was processed.
101     bool isImeConnectionActive;
102     // The timestamp for when the dispatching decisions were made for the event by the system.
103     nsecs_t processingTimestamp;
104 };
105 
106 /** Additional information about an input event being dispatched to a window. */
107 struct WindowDispatchArgs {
108     TracedEvent eventEntry;
109     nsecs_t deliveryTime;
110     int32_t resolvedFlags;
111     gui::Uid targetUid;
112     int64_t vsyncId;
113     int32_t windowId;
114     ui::Transform transform;
115     ui::Transform rawTransform;
116     std::array<uint8_t, 32> hmac;
117     int32_t resolvedKeyRepeatCount;
118 };
119 
120 /**
121  * An interface for the tracing backend, used for setting a custom backend for testing.
122  */
123 class InputTracingBackendInterface {
124 public:
125     virtual ~InputTracingBackendInterface() = default;
126 
127     /** Trace a KeyEvent. */
128     virtual void traceKeyEvent(const TracedKeyEvent&, const TracedEventMetadata&) = 0;
129 
130     /** Trace a MotionEvent. */
131     virtual void traceMotionEvent(const TracedMotionEvent&, const TracedEventMetadata&) = 0;
132 
133     /** Trace an event being sent to a window. */
134     virtual void traceWindowDispatch(const WindowDispatchArgs&, const TracedEventMetadata&) = 0;
135 };
136 
137 } // namespace android::inputdispatcher::trace
138