1 /* 2 * Copyright (C) 2019 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 "InjectionState.h" 20 #include "InputTargetFlags.h" 21 #include "trace/EventTrackerInterface.h" 22 23 #include <gui/InputApplication.h> 24 #include <input/Input.h> 25 #include <stdint.h> 26 #include <utils/Timers.h> 27 #include <functional> 28 #include <ostream> 29 #include <string> 30 31 namespace android::inputdispatcher { 32 33 struct EventEntry { 34 enum class Type { 35 DEVICE_RESET, 36 FOCUS, 37 KEY, 38 MOTION, 39 SENSOR, 40 POINTER_CAPTURE_CHANGED, 41 DRAG, 42 TOUCH_MODE_CHANGED, 43 44 ftl_last = TOUCH_MODE_CHANGED 45 }; 46 47 int32_t id; 48 Type type; 49 nsecs_t eventTime; 50 uint32_t policyFlags; 51 std::shared_ptr<InjectionState> injectionState; 52 53 mutable bool dispatchInProgress; // initially false, set to true while dispatching 54 55 /** 56 * Injected keys are events from an external (probably untrusted) application 57 * and are not related to real hardware state. They come in via 58 * InputDispatcher::injectInputEvent, which sets policy flag POLICY_FLAG_INJECTED. 59 */ isInjectedEventEntry60 inline bool isInjected() const { return injectionState != nullptr; } 61 62 /** 63 * Synthesized events are either injected events, or events that come 64 * from real hardware, but aren't directly attributable to a specific hardware event. 65 * Key repeat is a synthesized event, because it is related to an actual hardware state 66 * (a key is currently pressed), but the repeat itself is generated by the framework. 67 */ isSynthesizedEventEntry68 inline bool isSynthesized() const { 69 return isInjected() || IdGenerator::getSource(id) != IdGenerator::Source::INPUT_READER; 70 } 71 72 virtual std::string getDescription() const = 0; 73 74 EventEntry(int32_t id, Type type, nsecs_t eventTime, uint32_t policyFlags); 75 EventEntry(const EventEntry&) = delete; 76 EventEntry& operator=(const EventEntry&) = delete; 77 virtual ~EventEntry() = default; 78 }; 79 80 struct DeviceResetEntry : EventEntry { 81 int32_t deviceId; 82 83 DeviceResetEntry(int32_t id, nsecs_t eventTime, int32_t deviceId); 84 std::string getDescription() const override; 85 }; 86 87 struct FocusEntry : EventEntry { 88 sp<IBinder> connectionToken; 89 bool hasFocus; 90 std::string reason; 91 92 FocusEntry(int32_t id, nsecs_t eventTime, sp<IBinder> connectionToken, bool hasFocus, 93 const std::string& reason); 94 std::string getDescription() const override; 95 }; 96 97 struct PointerCaptureChangedEntry : EventEntry { 98 const PointerCaptureRequest pointerCaptureRequest; 99 100 PointerCaptureChangedEntry(int32_t id, nsecs_t eventTime, const PointerCaptureRequest&); 101 std::string getDescription() const override; 102 }; 103 104 struct DragEntry : EventEntry { 105 sp<IBinder> connectionToken; 106 bool isExiting; 107 float x, y; 108 109 DragEntry(int32_t id, nsecs_t eventTime, sp<IBinder> connectionToken, bool isExiting, float x, 110 float y); 111 std::string getDescription() const override; 112 }; 113 114 struct KeyEntry : EventEntry { 115 int32_t deviceId; 116 uint32_t source; 117 ui::LogicalDisplayId displayId; 118 int32_t action; 119 int32_t keyCode; 120 int32_t scanCode; 121 int32_t metaState; 122 nsecs_t downTime; 123 std::unique_ptr<trace::EventTrackerInterface> traceTracker; 124 125 bool syntheticRepeat; // set to true for synthetic key repeats 126 127 enum class InterceptKeyResult { 128 UNKNOWN, 129 SKIP, 130 CONTINUE, 131 TRY_AGAIN_LATER, 132 }; 133 // These are special fields that may need to be modified while the event is being dispatched. 134 mutable InterceptKeyResult interceptKeyResult; // set based on the interception result 135 mutable nsecs_t interceptKeyWakeupTime; // used with INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER 136 mutable int32_t flags; 137 // TODO(b/328618922): Refactor key repeat generation to make repeatCount non-mutable. 138 mutable int32_t repeatCount; 139 140 KeyEntry(int32_t id, std::shared_ptr<InjectionState> injectionState, nsecs_t eventTime, 141 int32_t deviceId, uint32_t source, ui::LogicalDisplayId displayId, 142 uint32_t policyFlags, int32_t action, int32_t flags, int32_t keyCode, int32_t scanCode, 143 int32_t metaState, int32_t repeatCount, nsecs_t downTime); 144 std::string getDescription() const override; 145 }; 146 147 std::ostream& operator<<(std::ostream& out, const KeyEntry& motionEntry); 148 149 struct MotionEntry : EventEntry { 150 int32_t deviceId; 151 uint32_t source; 152 ui::LogicalDisplayId displayId; 153 int32_t action; 154 int32_t actionButton; 155 int32_t flags; 156 int32_t metaState; 157 int32_t buttonState; 158 MotionClassification classification; 159 int32_t edgeFlags; 160 float xPrecision; 161 float yPrecision; 162 float xCursorPosition; 163 float yCursorPosition; 164 nsecs_t downTime; 165 std::vector<PointerProperties> pointerProperties; 166 std::vector<PointerCoords> pointerCoords; 167 std::unique_ptr<trace::EventTrackerInterface> traceTracker; 168 getPointerCountMotionEntry169 size_t getPointerCount() const { return pointerProperties.size(); } 170 171 MotionEntry(int32_t id, std::shared_ptr<InjectionState> injectionState, nsecs_t eventTime, 172 int32_t deviceId, uint32_t source, ui::LogicalDisplayId displayId, 173 uint32_t policyFlags, int32_t action, int32_t actionButton, int32_t flags, 174 int32_t metaState, int32_t buttonState, MotionClassification classification, 175 int32_t edgeFlags, float xPrecision, float yPrecision, float xCursorPosition, 176 float yCursorPosition, nsecs_t downTime, 177 const std::vector<PointerProperties>& pointerProperties, 178 const std::vector<PointerCoords>& pointerCoords); 179 std::string getDescription() const override; 180 }; 181 182 std::ostream& operator<<(std::ostream& out, const MotionEntry& motionEntry); 183 184 struct SensorEntry : EventEntry { 185 int32_t deviceId; 186 uint32_t source; 187 InputDeviceSensorType sensorType; 188 InputDeviceSensorAccuracy accuracy; 189 bool accuracyChanged; 190 nsecs_t hwTimestamp; 191 192 std::vector<float> values; 193 194 SensorEntry(int32_t id, nsecs_t eventTime, int32_t deviceId, uint32_t source, 195 uint32_t policyFlags, nsecs_t hwTimestamp, InputDeviceSensorType sensorType, 196 InputDeviceSensorAccuracy accuracy, bool accuracyChanged, 197 std::vector<float> values); 198 std::string getDescription() const override; 199 }; 200 201 struct TouchModeEntry : EventEntry { 202 bool inTouchMode; 203 ui::LogicalDisplayId displayId; 204 205 TouchModeEntry(int32_t id, nsecs_t eventTime, bool inTouchMode, ui::LogicalDisplayId displayId); 206 std::string getDescription() const override; 207 }; 208 209 // Tracks the progress of dispatching a particular event to a particular connection. 210 struct DispatchEntry { 211 const uint32_t seq; // unique sequence number, never 0 212 213 std::shared_ptr<const EventEntry> eventEntry; // the event to dispatch 214 const ftl::Flags<InputTargetFlags> targetFlags; 215 ui::Transform transform; 216 ui::Transform rawTransform; 217 float globalScaleFactor; 218 // Both deliveryTime and timeoutTime are only populated when the entry is sent to the app, 219 // and will be undefined before that. 220 nsecs_t deliveryTime; // time when the event was actually delivered 221 // An ANR will be triggered if a response for this entry is not received by timeoutTime 222 nsecs_t timeoutTime; 223 224 int32_t resolvedFlags; 225 226 // Information about the dispatch window used for tracing. We avoid holding a window handle 227 // here because information in a window handle may be dynamically updated within the lifespan 228 // of this dispatch entry. 229 gui::Uid targetUid; 230 int64_t vsyncId; 231 // The window that this event is targeting. The only case when this windowId is not populated 232 // is when dispatching an event to a global monitor. 233 std::optional<int32_t> windowId; 234 235 DispatchEntry(std::shared_ptr<const EventEntry> eventEntry, 236 ftl::Flags<InputTargetFlags> targetFlags, const ui::Transform& transform, 237 const ui::Transform& rawTransform, float globalScaleFactor, gui::Uid targetUid, 238 int64_t vsyncId, std::optional<int32_t> windowId); 239 DispatchEntry(const DispatchEntry&) = delete; 240 DispatchEntry& operator=(const DispatchEntry&) = delete; 241 hasForegroundTargetDispatchEntry242 inline bool hasForegroundTarget() const { 243 return targetFlags.test(InputTargetFlags::FOREGROUND); 244 } 245 isSplitDispatchEntry246 inline bool isSplit() const { return targetFlags.test(InputTargetFlags::SPLIT); } 247 248 private: 249 static volatile int32_t sNextSeqAtomic; 250 251 static uint32_t nextSeq(); 252 }; 253 254 std::ostream& operator<<(std::ostream& out, const DispatchEntry& entry); 255 256 VerifiedKeyEvent verifiedKeyEventFromKeyEntry(const KeyEntry& entry); 257 VerifiedMotionEvent verifiedMotionEventFromMotionEntry(const MotionEntry& entry, 258 const ui::Transform& rawTransform); 259 260 } // namespace android::inputdispatcher 261