blob: 756483904e5d36f6845c60b2f3c4ad1be2cdf9c5 [file] [log] [blame]
Michael Wrightd02c5b62014-02-10 15:10:22 -08001/*
2 * Copyright (C) 2010 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#ifndef _UI_INPUT_DISPATCHER_H
18#define _UI_INPUT_DISPATCHER_H
19
Siarhei Vishniakoue4623042020-03-25 16:16:40 -070020#include "AnrTracker.h"
Garfield Tane84e6f92019-08-29 17:28:41 -070021#include "CancelationOptions.h"
arthurhung6d4bed92021-03-17 11:59:33 +080022#include "DragState.h"
Garfield Tane84e6f92019-08-29 17:28:41 -070023#include "Entry.h"
Vishnu Nairc519ff72021-01-21 08:23:08 -080024#include "FocusResolver.h"
Garfield Tane84e6f92019-08-29 17:28:41 -070025#include "InjectionState.h"
26#include "InputDispatcherConfiguration.h"
27#include "InputDispatcherInterface.h"
28#include "InputDispatcherPolicyInterface.h"
29#include "InputState.h"
30#include "InputTarget.h"
Prabir Pradhan5a57cff2019-10-31 18:40:33 -070031#include "InputThread.h"
Siarhei Vishniakoua04181f2021-03-26 05:56:49 +000032#include "LatencyAggregator.h"
Siarhei Vishniakouf2652122021-03-05 21:39:46 +000033#include "LatencyTracker.h"
Garfield Tane84e6f92019-08-29 17:28:41 -070034#include "Monitor.h"
35#include "TouchState.h"
36#include "TouchedWindow.h"
37
chaviw09c8d2d2020-08-24 15:48:26 -070038#include <attestation/HmacKeyManager.h>
chaviw98318de2021-05-19 16:45:23 -050039#include <gui/InputApplication.h>
40#include <gui/WindowInfo.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080041#include <input/Input.h>
42#include <input/InputTransport.h>
Garfield Tane84e6f92019-08-29 17:28:41 -070043#include <limits.h>
44#include <stddef.h>
Michael Wright3dd60e22019-03-27 22:06:44 +000045#include <ui/Region.h>
Garfield Tane84e6f92019-08-29 17:28:41 -070046#include <unistd.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080047#include <utils/BitSet.h>
Garfield Tan0fc2fa72019-08-29 17:22:15 -070048#include <utils/Looper.h>
Garfield Tan0fc2fa72019-08-29 17:22:15 -070049#include <utils/Timers.h>
50#include <utils/threads.h>
51#include <condition_variable>
Garfield Tane84e6f92019-08-29 17:28:41 -070052#include <deque>
Garfield Tan0fc2fa72019-08-29 17:22:15 -070053#include <optional>
Robert Carr5c8a0262018-10-03 16:30:44 -070054#include <unordered_map>
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +000055#include <unordered_set>
Michael Wrightd02c5b62014-02-10 15:10:22 -080056
Garfield Tane84e6f92019-08-29 17:28:41 -070057#include <InputListener.h>
58#include <InputReporterInterface.h>
chaviw15fab6f2021-06-07 14:15:52 -050059#include <gui/WindowInfosListener.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080060
Garfield Tane84e6f92019-08-29 17:28:41 -070061namespace android::inputdispatcher {
Michael Wrightd02c5b62014-02-10 15:10:22 -080062
Garfield Tane84e6f92019-08-29 17:28:41 -070063class Connection;
Michael Wrightd02c5b62014-02-10 15:10:22 -080064
65/* Dispatches events to input targets. Some functions of the input dispatcher, such as
66 * identifying input targets, are controlled by a separate policy object.
67 *
68 * IMPORTANT INVARIANT:
69 * Because the policy can potentially block or cause re-entrance into the input dispatcher,
70 * the input dispatcher never calls into the policy while holding its internal locks.
71 * The implementation is also carefully designed to recover from scenarios such as an
72 * input channel becoming unregistered while identifying input targets or processing timeouts.
73 *
74 * Methods marked 'Locked' must be called with the lock acquired.
75 *
76 * Methods marked 'LockedInterruptible' must be called with the lock acquired but
77 * may during the course of their execution release the lock, call into the policy, and
78 * then reacquire the lock. The caller is responsible for recovering gracefully.
79 *
80 * A 'LockedInterruptible' method may called a 'Locked' method, but NOT vice-versa.
81 */
Siarhei Vishniakou18050092021-09-01 13:32:49 -070082class InputDispatcher : public android::InputDispatcherInterface {
Michael Wrightd02c5b62014-02-10 15:10:22 -080083public:
Antonio Kantekf16f2832021-09-28 04:39:20 +000084 static constexpr bool kDefaultInTouchMode = true;
85
Michael Wrightd02c5b62014-02-10 15:10:22 -080086 explicit InputDispatcher(const sp<InputDispatcherPolicyInterface>& policy);
Siarhei Vishniakou18050092021-09-01 13:32:49 -070087 ~InputDispatcher() override;
Michael Wrightd02c5b62014-02-10 15:10:22 -080088
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +000089 void dump(std::string& dump) override;
90 void monitor() override;
91 bool waitForIdle() override;
92 status_t start() override;
93 status_t stop() override;
Michael Wrightd02c5b62014-02-10 15:10:22 -080094
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +000095 void notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args) override;
96 void notifyKey(const NotifyKeyArgs* args) override;
97 void notifyMotion(const NotifyMotionArgs* args) override;
98 void notifySwitch(const NotifySwitchArgs* args) override;
99 void notifySensor(const NotifySensorArgs* args) override;
100 void notifyVibratorState(const NotifyVibratorStateArgs* args) override;
101 void notifyDeviceReset(const NotifyDeviceResetArgs* args) override;
102 void notifyPointerCaptureChanged(const NotifyPointerCaptureChangedArgs* args) override;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800103
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +0000104 android::os::InputEventInjectionResult injectInputEvent(
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800105 const InputEvent* event, int32_t injectorPid, int32_t injectorUid,
106 android::os::InputEventInjectionSync syncMode, std::chrono::milliseconds timeout,
107 uint32_t policyFlags) override;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800108
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +0000109 std::unique_ptr<VerifiedInputEvent> verifyInputEvent(const InputEvent& event) override;
Siarhei Vishniakou54d3e182020-01-15 17:38:38 -0800110
chaviw98318de2021-05-19 16:45:23 -0500111 void setInputWindows(
112 const std::unordered_map<int32_t, std::vector<sp<android::gui::WindowInfoHandle>>>&
113 handlesPerDisplay) override;
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +0000114 void setFocusedApplication(
Chris Yea209fde2020-07-22 13:54:51 -0700115 int32_t displayId,
116 const std::shared_ptr<InputApplicationHandle>& inputApplicationHandle) override;
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +0000117 void setFocusedDisplay(int32_t displayId) override;
118 void setInputDispatchMode(bool enabled, bool frozen) override;
119 void setInputFilterEnabled(bool enabled) override;
120 void setInTouchMode(bool inTouchMode) override;
121 void setMaximumObscuringOpacityForTouch(float opacity) override;
122 void setBlockUntrustedTouchesMode(android::os::BlockUntrustedTouchesMode mode) override;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800123
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +0000124 bool transferTouchFocus(const sp<IBinder>& fromToken, const sp<IBinder>& toToken,
125 bool isDragDrop = false) override;
126 bool transferTouch(const sp<IBinder>& destChannelToken) override;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800127
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +0000128 base::Result<std::unique_ptr<InputChannel>> createInputChannel(
Garfield Tan15601662020-09-22 15:32:38 -0700129 const std::string& name) override;
chaviw98318de2021-05-19 16:45:23 -0500130 void setFocusedWindow(const android::gui::FocusRequest&) override;
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +0000131 base::Result<std::unique_ptr<InputChannel>> createInputMonitor(int32_t displayId,
132 bool isGestureMonitor,
133 const std::string& name,
134 int32_t pid) override;
135 status_t removeInputChannel(const sp<IBinder>& connectionToken) override;
136 status_t pilferPointers(const sp<IBinder>& token) override;
137 void requestPointerCapture(const sp<IBinder>& windowToken, bool enabled) override;
138 bool flushSensor(int deviceId, InputDeviceSensorType sensorType) override;
Christine Franksb768bb42021-11-29 12:11:31 -0800139 void setDisplayEligibilityForPointerCapture(int displayId, bool isEligible) override;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800140
chaviw09c8d2d2020-08-24 15:48:26 -0700141 std::array<uint8_t, 32> sign(const VerifiedInputEvent& event) const;
142
Vishnu Nair599f1412021-06-21 10:39:58 -0700143 void displayRemoved(int32_t displayId) override;
144
Siarhei Vishniakou18050092021-09-01 13:32:49 -0700145 // Public because it's also used by tests to simulate the WindowInfosListener callback
146 void onWindowInfosChanged(const std::vector<android::gui::WindowInfo>& windowInfos,
147 const std::vector<android::gui::DisplayInfo>& displayInfos);
chaviw15fab6f2021-06-07 14:15:52 -0500148
Arthur Hungdfd528e2021-12-08 13:23:04 +0000149 void cancelCurrentTouch() override;
150
Michael Wrightd02c5b62014-02-10 15:10:22 -0800151private:
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700152 enum class DropReason {
153 NOT_DROPPED,
154 POLICY,
155 APP_SWITCH,
156 DISABLED,
157 BLOCKED,
158 STALE,
Prabir Pradhan99987712020-11-10 18:43:05 -0800159 NO_POINTER_CAPTURE,
Michael Wrightd02c5b62014-02-10 15:10:22 -0800160 };
161
Prabir Pradhan5a57cff2019-10-31 18:40:33 -0700162 std::unique_ptr<InputThread> mThread;
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700163
Michael Wrightd02c5b62014-02-10 15:10:22 -0800164 sp<InputDispatcherPolicyInterface> mPolicy;
Garfield Tane84e6f92019-08-29 17:28:41 -0700165 android::InputDispatcherConfiguration mConfig;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800166
Siarhei Vishniakou443ad902019-03-06 17:25:41 -0800167 std::mutex mLock;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800168
Siarhei Vishniakou443ad902019-03-06 17:25:41 -0800169 std::condition_variable mDispatcherIsAlive;
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -0800170 std::condition_variable mDispatcherEnteredIdle;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800171
172 sp<Looper> mLooper;
173
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700174 std::shared_ptr<EventEntry> mPendingEvent GUARDED_BY(mLock);
175 std::deque<std::shared_ptr<EventEntry>> mInboundQueue GUARDED_BY(mLock);
176 std::deque<std::shared_ptr<EventEntry>> mRecentQueue GUARDED_BY(mLock);
Prabir Pradhancef936d2021-07-21 16:17:52 +0000177
178 // A command entry captures state and behavior for an action to be performed in the
179 // dispatch loop after the initial processing has taken place. It is essentially
180 // a kind of continuation used to postpone sensitive policy interactions to a point
181 // in the dispatch loop where it is safe to release the lock (generally after finishing
182 // the critical parts of the dispatch cycle).
183 //
184 // The special thing about commands is that they can voluntarily release and reacquire
185 // the dispatcher lock at will. Initially when the command starts running, the
186 // dispatcher lock is held. However, if the command needs to call into the policy to
187 // do some work, it can release the lock, do the work, then reacquire the lock again
188 // before returning.
189 //
190 // This mechanism is a bit clunky but it helps to preserve the invariant that the dispatch
191 // never calls into the policy while holding its lock.
192 //
193 // Commands are called with the lock held, but they can release and re-acquire the lock from
194 // within.
195 using Command = std::function<void()>;
196 std::deque<Command> mCommandQueue GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800197
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800198 DropReason mLastDropReason GUARDED_BY(mLock);
Michael Wright3a981722015-06-10 15:26:13 +0100199
Garfield Tan1c7bc862020-01-28 13:24:04 -0800200 const IdGenerator mIdGenerator;
201
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700202 // With each iteration, InputDispatcher nominally processes one queued event,
203 // a timeout, or a response from an input consumer.
204 // This method should only be called on the input dispatcher's own thread.
205 void dispatchOnce();
206
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800207 void dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800208
209 // Enqueues an inbound event. Returns true if mLooper->wake() should be called.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700210 bool enqueueInboundEventLocked(std::unique_ptr<EventEntry> entry) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800211
212 // Cleans up input state when dropping an inbound event.
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700213 void dropInboundEventLocked(const EventEntry& entry, DropReason dropReason) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800214
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +0100215 // Enqueues a focus event.
Vishnu Nairad321cd2020-08-20 16:40:21 -0700216 void enqueueFocusEventLocked(const sp<IBinder>& windowToken, bool hasFocus,
Vishnu Nairc519ff72021-01-21 08:23:08 -0800217 const std::string& reason) REQUIRES(mLock);
arthurhungb89ccb02020-12-30 16:19:01 +0800218 // Enqueues a drag event.
chaviw98318de2021-05-19 16:45:23 -0500219 void enqueueDragEventLocked(const sp<android::gui::WindowInfoHandle>& windowToken,
220 bool isExiting, const MotionEntry& motionEntry) REQUIRES(mLock);
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +0100221
Michael Wrightd02c5b62014-02-10 15:10:22 -0800222 // Adds an event to a queue of recent events for debugging purposes.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700223 void addRecentEventLocked(std::shared_ptr<EventEntry> entry) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800224
225 // App switch latency optimization.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800226 bool mAppSwitchSawKeyDown GUARDED_BY(mLock);
227 nsecs_t mAppSwitchDueTime GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800228
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700229 bool isAppSwitchKeyEvent(const KeyEntry& keyEntry);
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800230 bool isAppSwitchPendingLocked() REQUIRES(mLock);
231 void resetPendingAppSwitchLocked(bool handled) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800232
Michael Wrightd02c5b62014-02-10 15:10:22 -0800233 // Blocked event latency optimization. Drops old events when the user intends
234 // to transfer focus to a new application.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700235 std::shared_ptr<EventEntry> mNextUnblockedEvent GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800236
Prabir Pradhand65552b2021-10-07 11:23:50 -0700237 sp<android::gui::WindowInfoHandle> findTouchedWindowAtLocked(
238 int32_t displayId, int32_t x, int32_t y, TouchState* touchState, bool isStylus = false,
239 bool addOutsideTargets = false, bool ignoreDragWindow = false) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800240
Prabir Pradhand65552b2021-10-07 11:23:50 -0700241 std::vector<sp<android::gui::WindowInfoHandle>> findTouchedSpyWindowsAtLocked(
242 int32_t displayId, int32_t x, int32_t y, bool isStylus) const REQUIRES(mLock);
Prabir Pradhan07e05b62021-11-19 03:57:24 -0800243
Siarhei Vishniakouffaa2b12020-05-26 21:43:02 -0700244 sp<Connection> getConnectionLocked(const sp<IBinder>& inputConnectionToken) const
245 REQUIRES(mLock);
246
Siarhei Vishniakouad991402020-10-28 11:40:09 -0500247 std::string getConnectionNameLocked(const sp<IBinder>& connectionToken) const REQUIRES(mLock);
248
Siarhei Vishniakouffaa2b12020-05-26 21:43:02 -0700249 void removeConnectionLocked(const sp<Connection>& connection) REQUIRES(mLock);
250
Prabir Pradhan6a9a8312021-04-23 11:59:31 -0700251 template <typename T>
252 struct StrongPointerHash {
253 std::size_t operator()(const sp<T>& b) const { return std::hash<T*>{}(b.get()); }
Robert Carr5c8a0262018-10-03 16:30:44 -0700254 };
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +0000255
256 // All registered connections mapped by input channel token.
257 std::unordered_map<sp<IBinder>, sp<Connection>, StrongPointerHash<IBinder>> mConnectionsByToken
258 GUARDED_BY(mLock);
Robert Carr5c8a0262018-10-03 16:30:44 -0700259
Michael Wright3dd60e22019-03-27 22:06:44 +0000260 // Finds the display ID of the gesture monitor identified by the provided token.
261 std::optional<int32_t> findGestureMonitorDisplayByTokenLocked(const sp<IBinder>& token)
262 REQUIRES(mLock);
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000263 // Find a monitor pid by the provided token.
264 std::optional<int32_t> findMonitorPidByTokenLocked(const sp<IBinder>& token) REQUIRES(mLock);
Michael Wright3dd60e22019-03-27 22:06:44 +0000265
Arthur Hung2fbf37f2018-09-13 18:16:41 +0800266 // Input channels that will receive a copy of all input events sent to the provided display.
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700267 std::unordered_map<int32_t, std::vector<Monitor>> mGlobalMonitorsByDisplay GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800268
Michael Wright3dd60e22019-03-27 22:06:44 +0000269 // Input channels that will receive pointer events that start within the corresponding display.
270 // These are a bit special when compared to global monitors since they'll cause gesture streams
271 // to continue even when there isn't a touched window,and have the ability to steal the rest of
272 // the pointer stream in order to claim it for a system gesture.
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700273 std::unordered_map<int32_t, std::vector<Monitor>> mGestureMonitorsByDisplay GUARDED_BY(mLock);
Michael Wright3dd60e22019-03-27 22:06:44 +0000274
Edgar Arriaga3d61bc12020-04-16 18:46:48 -0700275 const HmacKeyManager mHmacKeyManager;
276 const std::array<uint8_t, 32> getSignature(const MotionEntry& motionEntry,
277 const DispatchEntry& dispatchEntry) const;
278 const std::array<uint8_t, 32> getSignature(const KeyEntry& keyEntry,
279 const DispatchEntry& dispatchEntry) const;
Gang Wange9087892020-01-07 12:17:14 -0500280
Michael Wrightd02c5b62014-02-10 15:10:22 -0800281 // Event injection and synchronization.
Siarhei Vishniakou443ad902019-03-06 17:25:41 -0800282 std::condition_variable mInjectionResultAvailable;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800283 bool hasInjectionPermission(int32_t injectorPid, int32_t injectorUid);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700284 void setInjectionResult(EventEntry& entry,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800285 android::os::InputEventInjectionResult injectionResult);
Prabir Pradhandaa2f142021-12-10 09:30:08 +0000286 void transformMotionEntryForInjectionLocked(MotionEntry&,
287 const ui::Transform& injectedTransform) const
288 REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800289
Siarhei Vishniakou443ad902019-03-06 17:25:41 -0800290 std::condition_variable mInjectionSyncFinished;
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700291 void incrementPendingForegroundDispatches(EventEntry& entry);
292 void decrementPendingForegroundDispatches(EventEntry& entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800293
294 // Key repeat tracking.
295 struct KeyRepeatState {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700296 std::shared_ptr<KeyEntry> lastKeyEntry; // or null if no repeat
Michael Wrightd02c5b62014-02-10 15:10:22 -0800297 nsecs_t nextRepeatTime;
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800298 } mKeyRepeatState GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800299
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800300 void resetKeyRepeatLocked() REQUIRES(mLock);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700301 std::shared_ptr<KeyEntry> synthesizeKeyRepeatLocked(nsecs_t currentTime) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800302
Michael Wright78f24442014-08-06 15:55:28 -0700303 // Key replacement tracking
304 struct KeyReplacement {
305 int32_t keyCode;
306 int32_t deviceId;
307 bool operator==(const KeyReplacement& rhs) const {
308 return keyCode == rhs.keyCode && deviceId == rhs.deviceId;
309 }
Siarhei Vishniakoubde3d9e2020-03-24 19:05:54 -0700310 };
311 struct KeyReplacementHash {
312 size_t operator()(const KeyReplacement& key) const {
313 return std::hash<int32_t>()(key.keyCode) ^ (std::hash<int32_t>()(key.deviceId) << 1);
Michael Wright78f24442014-08-06 15:55:28 -0700314 }
315 };
316 // Maps the key code replaced, device id tuple to the key code it was replaced with
Siarhei Vishniakoubde3d9e2020-03-24 19:05:54 -0700317 std::unordered_map<KeyReplacement, int32_t, KeyReplacementHash> mReplacedKeys GUARDED_BY(mLock);
Siarhei Vishniakou61fafdd2018-04-13 11:00:58 -0500318 // Process certain Meta + Key combinations
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700319 void accelerateMetaShortcuts(const int32_t deviceId, const int32_t action, int32_t& keyCode,
320 int32_t& metaState);
Michael Wright78f24442014-08-06 15:55:28 -0700321
Michael Wrightd02c5b62014-02-10 15:10:22 -0800322 // Deferred command processing.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800323 bool haveCommandsLocked() const REQUIRES(mLock);
Prabir Pradhancef936d2021-07-21 16:17:52 +0000324 bool runCommandsLockedInterruptable() REQUIRES(mLock);
325 void postCommandLocked(Command&& command) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800326
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700327 nsecs_t processAnrsLocked() REQUIRES(mLock);
Siarhei Vishniakou70622952020-07-30 11:17:23 -0500328 std::chrono::nanoseconds getDispatchingTimeoutLocked(const sp<IBinder>& token) REQUIRES(mLock);
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700329
Michael Wrightd02c5b62014-02-10 15:10:22 -0800330 // Input filter processing.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800331 bool shouldSendKeyToInputFilterLocked(const NotifyKeyArgs* args) REQUIRES(mLock);
332 bool shouldSendMotionToInputFilterLocked(const NotifyMotionArgs* args) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800333
334 // Inbound event processing.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800335 void drainInboundQueueLocked() REQUIRES(mLock);
336 void releasePendingEventLocked() REQUIRES(mLock);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700337 void releaseInboundEventLocked(std::shared_ptr<EventEntry> entry) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800338
339 // Dispatch state.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800340 bool mDispatchEnabled GUARDED_BY(mLock);
341 bool mDispatchFrozen GUARDED_BY(mLock);
342 bool mInputFilterEnabled GUARDED_BY(mLock);
Siarhei Vishniakouf3bc1aa2019-11-25 13:48:53 -0800343 bool mInTouchMode GUARDED_BY(mLock);
Bernardo Rufinoea97d182020-08-19 14:43:14 +0100344 float mMaximumObscuringOpacityForTouch GUARDED_BY(mLock);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800345 android::os::BlockUntrustedTouchesMode mBlockUntrustedTouchesMode GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800346
Siarhei Vishniakou18050092021-09-01 13:32:49 -0700347 class DispatcherWindowListener : public gui::WindowInfosListener {
348 public:
349 explicit DispatcherWindowListener(InputDispatcher& dispatcher) : mDispatcher(dispatcher){};
350 void onWindowInfosChanged(
351 const std::vector<android::gui::WindowInfo>& windowInfos,
352 const std::vector<android::gui::DisplayInfo>& displayInfos) override;
353
354 private:
355 InputDispatcher& mDispatcher;
356 };
357 sp<gui::WindowInfosListener> mWindowInfoListener;
358
Prabir Pradhan48f8cb92021-08-26 14:05:36 -0700359 std::unordered_map<int32_t /*displayId*/, std::vector<sp<android::gui::WindowInfoHandle>>>
chaviw98318de2021-05-19 16:45:23 -0500360 mWindowHandlesByDisplay GUARDED_BY(mLock);
Prabir Pradhan48f8cb92021-08-26 14:05:36 -0700361 std::unordered_map<int32_t /*displayId*/, android::gui::DisplayInfo> mDisplayInfos
362 GUARDED_BY(mLock);
chaviw98318de2021-05-19 16:45:23 -0500363 void setInputWindowsLocked(
364 const std::vector<sp<android::gui::WindowInfoHandle>>& inputWindowHandles,
365 int32_t displayId) REQUIRES(mLock);
Vishnu Nairad321cd2020-08-20 16:40:21 -0700366 // Get a reference to window handles by display, return an empty vector if not found.
chaviw98318de2021-05-19 16:45:23 -0500367 const std::vector<sp<android::gui::WindowInfoHandle>>& getWindowHandlesLocked(
368 int32_t displayId) const REQUIRES(mLock);
369 sp<android::gui::WindowInfoHandle> getWindowHandleLocked(
370 const sp<IBinder>& windowHandleToken) const REQUIRES(mLock);
Vishnu Nairad321cd2020-08-20 16:40:21 -0700371
372 // Same function as above, but faster. Since displayId is provided, this avoids the need
373 // to loop through all displays.
chaviw98318de2021-05-19 16:45:23 -0500374 sp<android::gui::WindowInfoHandle> getWindowHandleLocked(const sp<IBinder>& windowHandleToken,
375 int displayId) const REQUIRES(mLock);
376 sp<android::gui::WindowInfoHandle> getWindowHandleLocked(
377 const sp<android::gui::WindowInfoHandle>& windowHandle) const REQUIRES(mLock);
Siarhei Vishniakouce5ab082020-07-09 17:03:21 -0500378 std::shared_ptr<InputChannel> getInputChannelLocked(const sp<IBinder>& windowToken) const
379 REQUIRES(mLock);
chaviw98318de2021-05-19 16:45:23 -0500380 sp<android::gui::WindowInfoHandle> getFocusedWindowHandleLocked(int displayId) const
381 REQUIRES(mLock);
382 bool hasResponsiveConnectionLocked(android::gui::WindowInfoHandle& windowHandle) const
383 REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800384
Antonio Kantek7242d8b2021-08-05 16:07:20 -0700385 // Gets all the input targets (with their respective input channels) from the window handles
386 // passed as argument.
387 std::vector<InputTarget> getInputTargetsFromWindowHandlesLocked(
388 const std::vector<sp<android::gui::WindowInfoHandle>>& windowHandles) const
389 REQUIRES(mLock);
390
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -0700391 /*
392 * Validate and update InputWindowHandles for a given display.
393 */
394 void updateWindowHandlesForDisplayLocked(
chaviw98318de2021-05-19 16:45:23 -0500395 const std::vector<sp<android::gui::WindowInfoHandle>>& inputWindowHandles,
396 int32_t displayId) REQUIRES(mLock);
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -0700397
Siarhei Vishniakoubde3d9e2020-03-24 19:05:54 -0700398 std::unordered_map<int32_t, TouchState> mTouchStatesByDisplay GUARDED_BY(mLock);
arthurhung6d4bed92021-03-17 11:59:33 +0800399 std::unique_ptr<DragState> mDragState GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800400
Vishnu Nair599f1412021-06-21 10:39:58 -0700401 void setFocusedApplicationLocked(
402 int32_t displayId,
403 const std::shared_ptr<InputApplicationHandle>& inputApplicationHandle) REQUIRES(mLock);
Tiger Huang721e26f2018-07-24 22:26:19 +0800404 // Focused applications.
Chris Yea209fde2020-07-22 13:54:51 -0700405 std::unordered_map<int32_t, std::shared_ptr<InputApplicationHandle>>
406 mFocusedApplicationHandlesByDisplay GUARDED_BY(mLock);
Tiger Huang721e26f2018-07-24 22:26:19 +0800407
408 // Top focused display.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800409 int32_t mFocusedDisplayId GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800410
Vishnu Nairc519ff72021-01-21 08:23:08 -0800411 // Keeps track of the focused window per display and determines focus changes.
412 FocusResolver mFocusResolver GUARDED_BY(mLock);
Prabir Pradhan5cc1a692021-08-06 14:01:18 +0000413
414 // The enabled state of this request is true iff the focused window on the focused display has
415 // requested Pointer Capture. This request also contains the sequence number associated with the
416 // current request. The state of this variable should always be in sync with the state of
417 // Pointer Capture in the policy, and is only updated through setPointerCaptureLocked(request).
418 PointerCaptureRequest mCurrentPointerCaptureRequest GUARDED_BY(mLock);
Prabir Pradhan99987712020-11-10 18:43:05 -0800419
420 // The window token that has Pointer Capture.
421 // This should be in sync with PointerCaptureChangedEvents dispatched to the input channel.
422 sp<IBinder> mWindowTokenWithPointerCapture GUARDED_BY(mLock);
423
Christine Franksb768bb42021-11-29 12:11:31 -0800424 // Displays that are ineligible for pointer capture.
425 // TODO(b/214621487): Remove or move to a display flag.
426 std::vector<int32_t> mIneligibleDisplaysForPointerCapture GUARDED_BY(mLock);
427
Prabir Pradhan99987712020-11-10 18:43:05 -0800428 // Disable Pointer Capture as a result of loss of window focus.
429 void disablePointerCaptureForcedLocked() REQUIRES(mLock);
430
431 // Set the Pointer Capture state in the Policy.
Prabir Pradhan5cc1a692021-08-06 14:01:18 +0000432 void setPointerCaptureLocked(bool enable) REQUIRES(mLock);
Prabir Pradhan99987712020-11-10 18:43:05 -0800433
Michael Wrightd02c5b62014-02-10 15:10:22 -0800434 // Dispatcher state at time of last ANR.
Siarhei Vishniakoub1a16272020-05-06 16:09:19 -0700435 std::string mLastAnrState GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800436
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +0000437 // The connection tokens of the channels that the user last interacted, for debugging
Prabir Pradhan6a9a8312021-04-23 11:59:31 -0700438 std::unordered_set<sp<IBinder>, StrongPointerHash<IBinder>> mInteractionConnectionTokens
439 GUARDED_BY(mLock);
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +0000440 void updateInteractionTokensLocked(const EventEntry& entry,
441 const std::vector<InputTarget>& targets) REQUIRES(mLock);
442
Michael Wrightd02c5b62014-02-10 15:10:22 -0800443 // Dispatch inbound events.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700444 bool dispatchConfigurationChangedLocked(nsecs_t currentTime,
445 const ConfigurationChangedEntry& entry) REQUIRES(mLock);
446 bool dispatchDeviceResetLocked(nsecs_t currentTime, const DeviceResetEntry& entry)
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700447 REQUIRES(mLock);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700448 bool dispatchKeyLocked(nsecs_t currentTime, std::shared_ptr<KeyEntry> entry,
449 DropReason* dropReason, nsecs_t* nextWakeupTime) REQUIRES(mLock);
450 bool dispatchMotionLocked(nsecs_t currentTime, std::shared_ptr<MotionEntry> entry,
451 DropReason* dropReason, nsecs_t* nextWakeupTime) REQUIRES(mLock);
452 void dispatchFocusLocked(nsecs_t currentTime, std::shared_ptr<FocusEntry> entry)
453 REQUIRES(mLock);
Prabir Pradhan99987712020-11-10 18:43:05 -0800454 void dispatchPointerCaptureChangedLocked(
455 nsecs_t currentTime, const std::shared_ptr<PointerCaptureChangedEntry>& entry,
456 DropReason& dropReason) REQUIRES(mLock);
Antonio Kantek7242d8b2021-08-05 16:07:20 -0700457 void dispatchTouchModeChangeLocked(nsecs_t currentTime,
458 const std::shared_ptr<TouchModeEntry>& entry)
459 REQUIRES(mLock);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700460 void dispatchEventLocked(nsecs_t currentTime, std::shared_ptr<EventEntry> entry,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700461 const std::vector<InputTarget>& inputTargets) REQUIRES(mLock);
Prabir Pradhancef936d2021-07-21 16:17:52 +0000462 void dispatchSensorLocked(nsecs_t currentTime, const std::shared_ptr<SensorEntry>& entry,
Chris Yef59a2f42020-10-16 12:55:26 -0700463 DropReason* dropReason, nsecs_t* nextWakeupTime) REQUIRES(mLock);
arthurhungb89ccb02020-12-30 16:19:01 +0800464 void dispatchDragLocked(nsecs_t currentTime, std::shared_ptr<DragEntry> entry) REQUIRES(mLock);
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700465 void logOutboundKeyDetails(const char* prefix, const KeyEntry& entry);
466 void logOutboundMotionDetails(const char* prefix, const MotionEntry& entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800467
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700468 /**
469 * This field is set if there is no focused window, and we have an event that requires
470 * a focused window to be dispatched (for example, a KeyEvent).
471 * When this happens, we will wait until *mNoFocusedWindowTimeoutTime before
472 * dropping the event and raising an ANR for that application.
473 * This is useful if an application is slow to add a focused window.
474 */
475 std::optional<nsecs_t> mNoFocusedWindowTimeoutTime GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800476
Siarhei Vishniakoude1bc4a2020-05-26 22:39:43 -0700477 bool shouldPruneInboundQueueLocked(const MotionEntry& motionEntry) REQUIRES(mLock);
478
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700479 /**
480 * Time to stop waiting for the events to be processed while trying to dispatch a key.
481 * When this time expires, we just send the pending key event to the currently focused window,
482 * without waiting on other events to be processed first.
483 */
484 std::optional<nsecs_t> mKeyIsWaitingForEventsTimeout GUARDED_BY(mLock);
485 bool shouldWaitToSendKeyLocked(nsecs_t currentTime, const char* focusedWindowName)
486 REQUIRES(mLock);
487
488 /**
489 * The focused application at the time when no focused window was present.
490 * Used to raise an ANR when we have no focused window.
491 */
Chris Yea209fde2020-07-22 13:54:51 -0700492 std::shared_ptr<InputApplicationHandle> mAwaitedFocusedApplication GUARDED_BY(mLock);
Siarhei Vishniakouf56b2692020-09-08 19:43:33 -0500493 /**
494 * The displayId that the focused application is associated with.
495 */
496 int32_t mAwaitedApplicationDisplayId GUARDED_BY(mLock);
497 void processNoFocusedWindowAnrLocked() REQUIRES(mLock);
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700498
Vishnu Nair958da932020-08-21 17:12:37 -0700499 /**
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000500 * Tell policy about a window or a monitor that just became unresponsive. Starts ANR.
501 */
502 void processConnectionUnresponsiveLocked(const Connection& connection, std::string reason)
503 REQUIRES(mLock);
504 /**
505 * Tell policy about a window or a monitor that just became responsive.
506 */
507 void processConnectionResponsiveLocked(const Connection& connection) REQUIRES(mLock);
508
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000509 void sendMonitorUnresponsiveCommandLocked(int32_t pid, std::string reason) REQUIRES(mLock);
Prabir Pradhancef936d2021-07-21 16:17:52 +0000510 void sendWindowUnresponsiveCommandLocked(const sp<IBinder>& connectionToken, std::string reason)
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000511 REQUIRES(mLock);
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000512 void sendMonitorResponsiveCommandLocked(int32_t pid) REQUIRES(mLock);
Prabir Pradhancef936d2021-07-21 16:17:52 +0000513 void sendWindowResponsiveCommandLocked(const sp<IBinder>& connectionToken) REQUIRES(mLock);
Vishnu Nair958da932020-08-21 17:12:37 -0700514
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700515 // Optimization: AnrTracker is used to quickly find which connection is due for a timeout next.
516 // AnrTracker must be kept in-sync with all responsive connection.waitQueues.
517 // If a connection is not responsive, then the entries should not be added to the AnrTracker.
518 // Once a connection becomes unresponsive, its entries are removed from AnrTracker to
519 // prevent unneeded wakeups.
520 AnrTracker mAnrTracker GUARDED_BY(mLock);
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700521
Michael Wrightd02c5b62014-02-10 15:10:22 -0800522 // Contains the last window which received a hover event.
chaviw98318de2021-05-19 16:45:23 -0500523 sp<android::gui::WindowInfoHandle> mLastHoverWindowHandle GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800524
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700525 void cancelEventsForAnrLocked(const sp<Connection>& connection) REQUIRES(mLock);
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800526 nsecs_t getTimeSpentWaitingForApplicationLocked(nsecs_t currentTime) REQUIRES(mLock);
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700527 // If a focused application changes, we should stop counting down the "no focused window" time,
528 // because we will have no way of knowing when the previous application actually added a window.
529 // This also means that we will miss cases like pulling down notification shade when the
530 // focused application does not have a focused window (no ANR will be raised if notification
531 // shade is pulled down while we are counting down the timeout).
532 void resetNoFocusedWindowTimeoutLocked() REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800533
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700534 int32_t getTargetDisplayId(const EventEntry& entry);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800535 android::os::InputEventInjectionResult findFocusedWindowTargetsLocked(
536 nsecs_t currentTime, const EventEntry& entry, std::vector<InputTarget>& inputTargets,
537 nsecs_t* nextWakeupTime) REQUIRES(mLock);
538 android::os::InputEventInjectionResult findTouchedWindowTargetsLocked(
539 nsecs_t currentTime, const MotionEntry& entry, std::vector<InputTarget>& inputTargets,
540 nsecs_t* nextWakeupTime, bool* outConflictingPointerActions) REQUIRES(mLock);
Prabir Pradhan0a99c922021-09-03 08:27:53 -0700541 std::vector<Monitor> selectResponsiveMonitorsLocked(
542 const std::vector<Monitor>& gestureMonitors) const REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800543
chaviw98318de2021-05-19 16:45:23 -0500544 void addWindowTargetLocked(const sp<android::gui::WindowInfoHandle>& windowHandle,
545 int32_t targetFlags, BitSet32 pointerIds,
546 std::vector<InputTarget>& inputTargets) REQUIRES(mLock);
Prabir Pradhan0a99c922021-09-03 08:27:53 -0700547 void addMonitoringTargetLocked(const Monitor& monitor, int32_t displayId,
548 std::vector<InputTarget>& inputTargets) REQUIRES(mLock);
549 void addGlobalMonitoringTargetsLocked(std::vector<InputTarget>& inputTargets, int32_t displayId)
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700550 REQUIRES(mLock);
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700551 void pokeUserActivityLocked(const EventEntry& eventEntry) REQUIRES(mLock);
chaviw98318de2021-05-19 16:45:23 -0500552 bool checkInjectionPermission(const sp<android::gui::WindowInfoHandle>& windowHandle,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700553 const InjectionState* injectionState);
arthurhungb89ccb02020-12-30 16:19:01 +0800554 // Enqueue a drag event if needed, and update the touch state.
555 // Uses findTouchedWindowTargetsLocked to make the decision
arthurhung6d4bed92021-03-17 11:59:33 +0800556 void addDragEventLocked(const MotionEntry& entry) REQUIRES(mLock);
557 void finishDragAndDrop(int32_t displayId, float x, float y) REQUIRES(mLock);
Bernardo Rufinoea97d182020-08-19 14:43:14 +0100558
559 struct TouchOcclusionInfo {
560 bool hasBlockingOcclusion;
561 float obscuringOpacity;
562 std::string obscuringPackage;
563 int32_t obscuringUid;
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +0000564 std::vector<std::string> debugInfo;
Bernardo Rufinoea97d182020-08-19 14:43:14 +0100565 };
566
chaviw98318de2021-05-19 16:45:23 -0500567 TouchOcclusionInfo computeTouchOcclusionInfoLocked(
568 const sp<android::gui::WindowInfoHandle>& windowHandle, int32_t x, int32_t y) const
569 REQUIRES(mLock);
Bernardo Rufinoea97d182020-08-19 14:43:14 +0100570 bool isTouchTrustedLocked(const TouchOcclusionInfo& occlusionInfo) const REQUIRES(mLock);
chaviw98318de2021-05-19 16:45:23 -0500571 bool isWindowObscuredAtPointLocked(const sp<android::gui::WindowInfoHandle>& windowHandle,
572 int32_t x, int32_t y) const REQUIRES(mLock);
573 bool isWindowObscuredLocked(const sp<android::gui::WindowInfoHandle>& windowHandle) const
574 REQUIRES(mLock);
575 std::string dumpWindowForTouchOcclusion(const android::gui::WindowInfo* info,
576 bool isTouchWindow) const;
Siarhei Vishniakou234129c2020-10-22 22:28:12 -0500577 std::string getApplicationWindowLabel(const InputApplicationHandle* applicationHandle,
chaviw98318de2021-05-19 16:45:23 -0500578 const sp<android::gui::WindowInfoHandle>& windowHandle);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800579
Vishnu Nair062a8672021-09-03 16:07:44 -0700580 bool shouldDropInput(const EventEntry& entry,
581 const sp<android::gui::WindowInfoHandle>& windowHandle) const
582 REQUIRES(mLock);
583
Michael Wrightd02c5b62014-02-10 15:10:22 -0800584 // Manage the dispatch cycle for a single connection.
585 // These methods are deliberately not Interruptible because doing all of the work
586 // with the mutex held makes it easier to ensure that connection invariants are maintained.
587 // If needed, the methods post commands to run later once the critical bits are done.
588 void prepareDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700589 std::shared_ptr<EventEntry>, const InputTarget& inputTarget)
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700590 REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800591 void enqueueDispatchEntriesLocked(nsecs_t currentTime, const sp<Connection>& connection,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700592 std::shared_ptr<EventEntry>, const InputTarget& inputTarget)
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700593 REQUIRES(mLock);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700594 void enqueueDispatchEntryLocked(const sp<Connection>& connection, std::shared_ptr<EventEntry>,
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -0800595 const InputTarget& inputTarget, int32_t dispatchMode)
chaviw8c9cf542019-03-25 13:02:48 -0700596 REQUIRES(mLock);
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800597 void startDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection)
598 REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800599 void finishDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,
Siarhei Vishniakou3531ae72021-02-02 12:12:27 -1000600 uint32_t seq, bool handled, nsecs_t consumeTime) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800601 void abortBrokenDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700602 bool notify) REQUIRES(mLock);
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -0700603 void drainDispatchQueue(std::deque<DispatchEntry*>& queue);
Siarhei Vishniakou62683e82019-03-06 17:59:56 -0800604 void releaseDispatchEntry(DispatchEntry* dispatchEntry);
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +0000605 int handleReceiveCallback(int events, sp<IBinder> connectionToken);
chaviw8c9cf542019-03-25 13:02:48 -0700606 // The action sent should only be of type AMOTION_EVENT_*
chaviwfd6d3512019-03-25 13:23:49 -0700607 void dispatchPointerDownOutsideFocus(uint32_t source, int32_t action,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700608 const sp<IBinder>& newToken) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800609
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700610 void synthesizeCancelationEventsForAllConnectionsLocked(const CancelationOptions& options)
611 REQUIRES(mLock);
612 void synthesizeCancelationEventsForMonitorsLocked(const CancelationOptions& options)
613 REQUIRES(mLock);
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800614 void synthesizeCancelationEventsForMonitorsLocked(
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700615 const CancelationOptions& options,
Michael Wright3dd60e22019-03-27 22:06:44 +0000616 std::unordered_map<int32_t, std::vector<Monitor>>& monitorsByDisplay) REQUIRES(mLock);
Siarhei Vishniakouce5ab082020-07-09 17:03:21 -0500617 void synthesizeCancelationEventsForInputChannelLocked(
618 const std::shared_ptr<InputChannel>& channel, const CancelationOptions& options)
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700619 REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800620 void synthesizeCancelationEventsForConnectionLocked(const sp<Connection>& connection,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700621 const CancelationOptions& options)
622 REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800623
Svet Ganov5d3bc372020-01-26 23:11:07 -0800624 void synthesizePointerDownEventsForConnectionLocked(const sp<Connection>& connection)
625 REQUIRES(mLock);
626
Michael Wrightd02c5b62014-02-10 15:10:22 -0800627 // Splitting motion events across windows.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700628 std::unique_ptr<MotionEntry> splitMotionEvent(const MotionEntry& originalMotionEntry,
629 BitSet32 pointerIds);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800630
631 // Reset and drop everything the dispatcher is doing.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800632 void resetAndDropEverythingLocked(const char* reason) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800633
634 // Dump state.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800635 void dumpDispatchStateLocked(std::string& dump) REQUIRES(mLock);
Michael Wright3dd60e22019-03-27 22:06:44 +0000636 void dumpMonitors(std::string& dump, const std::vector<Monitor>& monitors);
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800637 void logDispatchStateLocked() REQUIRES(mLock);
Prabir Pradhan99987712020-11-10 18:43:05 -0800638 std::string dumpPointerCaptureStateLocked() REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800639
640 // Registration.
Siarhei Vishniakouadefc3e2020-09-02 22:28:29 -0500641 void removeMonitorChannelLocked(const sp<IBinder>& connectionToken) REQUIRES(mLock);
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700642 void removeMonitorChannelLocked(
Siarhei Vishniakouadefc3e2020-09-02 22:28:29 -0500643 const sp<IBinder>& connectionToken,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700644 std::unordered_map<int32_t, std::vector<Monitor>>& monitorsByDisplay) REQUIRES(mLock);
Garfield Tan15601662020-09-22 15:32:38 -0700645 status_t removeInputChannelLocked(const sp<IBinder>& connectionToken, bool notify)
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800646 REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800647
648 // Interesting events that we might like to log or tell the framework about.
Prabir Pradhancef936d2021-07-21 16:17:52 +0000649 void doDispatchCycleFinishedCommand(nsecs_t finishTime, const sp<Connection>& connection,
650 uint32_t seq, bool handled, nsecs_t consumeTime)
Siarhei Vishniakou3531ae72021-02-02 12:12:27 -1000651 REQUIRES(mLock);
Prabir Pradhancef936d2021-07-21 16:17:52 +0000652 void doInterceptKeyBeforeDispatchingCommand(const sp<IBinder>& focusedWindowToken,
653 KeyEntry& entry) REQUIRES(mLock);
Vishnu Nairc519ff72021-01-21 08:23:08 -0800654 void onFocusChangedLocked(const FocusResolver::FocusChanges& changes) REQUIRES(mLock);
Prabir Pradhancef936d2021-07-21 16:17:52 +0000655 void sendFocusChangedCommandLocked(const sp<IBinder>& oldToken, const sp<IBinder>& newToken)
Vishnu Nairad321cd2020-08-20 16:40:21 -0700656 REQUIRES(mLock);
Prabir Pradhancef936d2021-07-21 16:17:52 +0000657 void sendDropWindowCommandLocked(const sp<IBinder>& token, float x, float y) REQUIRES(mLock);
658 void sendUntrustedTouchCommandLocked(const std::string& obscuringPackage) REQUIRES(mLock);
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000659 void onAnrLocked(const sp<Connection>& connection) REQUIRES(mLock);
Siarhei Vishniakou234129c2020-10-22 22:28:12 -0500660 void onAnrLocked(std::shared_ptr<InputApplicationHandle> application) REQUIRES(mLock);
chaviw98318de2021-05-19 16:45:23 -0500661 void updateLastAnrStateLocked(const sp<android::gui::WindowInfoHandle>& window,
662 const std::string& reason) REQUIRES(mLock);
Siarhei Vishniakou234129c2020-10-22 22:28:12 -0500663 void updateLastAnrStateLocked(const InputApplicationHandle& application,
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700664 const std::string& reason) REQUIRES(mLock);
665 void updateLastAnrStateLocked(const std::string& windowLabel, const std::string& reason)
666 REQUIRES(mLock);
Prabir Pradhancef936d2021-07-21 16:17:52 +0000667 bool afterKeyEventLockedInterruptable(const sp<Connection>& connection,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700668 DispatchEntry* dispatchEntry, KeyEntry& keyEntry,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700669 bool handled) REQUIRES(mLock);
Prabir Pradhancef936d2021-07-21 16:17:52 +0000670 bool afterMotionEventLockedInterruptable(const sp<Connection>& connection,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700671 DispatchEntry* dispatchEntry, MotionEntry& motionEntry,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700672 bool handled) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800673
Arthur Hungabbb9d82021-09-01 14:52:30 +0000674 // Find touched state and touched window by token.
675 std::pair<TouchState*, TouchedWindow*> findTouchStateAndWindowLocked(const sp<IBinder>& token)
676 REQUIRES(mLock);
677
Michael Wrightd02c5b62014-02-10 15:10:22 -0800678 // Statistics gathering.
Siarhei Vishniakoua04181f2021-03-26 05:56:49 +0000679 LatencyAggregator mLatencyAggregator GUARDED_BY(mLock);
Siarhei Vishniakouf2652122021-03-05 21:39:46 +0000680 LatencyTracker mLatencyTracker GUARDED_BY(mLock);
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800681 void traceInboundQueueLengthLocked() REQUIRES(mLock);
Siarhei Vishniakou060a7272021-02-03 19:40:10 +0000682 void traceOutboundQueueLength(const Connection& connection);
683 void traceWaitQueueLength(const Connection& connection);
Prabir Pradhanf93562f2018-11-29 12:13:37 -0800684
Prabir Pradhan79a4f0c2019-01-09 11:24:01 -0800685 sp<InputReporterInterface> mReporter;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800686};
687
Garfield Tane84e6f92019-08-29 17:28:41 -0700688} // namespace android::inputdispatcher
Michael Wrightd02c5b62014-02-10 15:10:22 -0800689
690#endif // _UI_INPUT_DISPATCHER_H