blob: d9677eb633cb7f79d67a2a5d4d2474a63e205a87 [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 Vishniakou289e9242022-02-15 14:50:16 -080087 explicit InputDispatcher(const sp<InputDispatcherPolicyInterface>& policy,
88 std::chrono::nanoseconds staleEventTimeout);
Siarhei Vishniakou18050092021-09-01 13:32:49 -070089 ~InputDispatcher() override;
Michael Wrightd02c5b62014-02-10 15:10:22 -080090
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +000091 void dump(std::string& dump) override;
92 void monitor() override;
93 bool waitForIdle() override;
94 status_t start() override;
95 status_t stop() override;
Michael Wrightd02c5b62014-02-10 15:10:22 -080096
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +000097 void notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args) override;
98 void notifyKey(const NotifyKeyArgs* args) override;
99 void notifyMotion(const NotifyMotionArgs* args) override;
100 void notifySwitch(const NotifySwitchArgs* args) override;
101 void notifySensor(const NotifySensorArgs* args) override;
102 void notifyVibratorState(const NotifyVibratorStateArgs* args) override;
103 void notifyDeviceReset(const NotifyDeviceResetArgs* args) override;
104 void notifyPointerCaptureChanged(const NotifyPointerCaptureChangedArgs* args) override;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800105
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +0000106 android::os::InputEventInjectionResult injectInputEvent(
Prabir Pradhan5735a322022-04-11 17:23:34 +0000107 const InputEvent* event, std::optional<int32_t> targetUid,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800108 android::os::InputEventInjectionSync syncMode, std::chrono::milliseconds timeout,
109 uint32_t policyFlags) override;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800110
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +0000111 std::unique_ptr<VerifiedInputEvent> verifyInputEvent(const InputEvent& event) override;
Siarhei Vishniakou54d3e182020-01-15 17:38:38 -0800112
chaviw98318de2021-05-19 16:45:23 -0500113 void setInputWindows(
114 const std::unordered_map<int32_t, std::vector<sp<android::gui::WindowInfoHandle>>>&
115 handlesPerDisplay) override;
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +0000116 void setFocusedApplication(
Chris Yea209fde2020-07-22 13:54:51 -0700117 int32_t displayId,
118 const std::shared_ptr<InputApplicationHandle>& inputApplicationHandle) override;
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +0000119 void setFocusedDisplay(int32_t displayId) override;
120 void setInputDispatchMode(bool enabled, bool frozen) override;
121 void setInputFilterEnabled(bool enabled) override;
Antonio Kantekea47acb2021-12-23 12:41:25 -0800122 bool setInTouchMode(bool inTouchMode, int32_t pid, int32_t uid, bool hasPermission) override;
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +0000123 void setMaximumObscuringOpacityForTouch(float opacity) override;
124 void setBlockUntrustedTouchesMode(android::os::BlockUntrustedTouchesMode mode) override;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800125
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +0000126 bool transferTouchFocus(const sp<IBinder>& fromToken, const sp<IBinder>& toToken,
127 bool isDragDrop = false) override;
Siarhei Vishniakou7ae7afd2022-03-31 15:26:13 -0700128 bool transferTouch(const sp<IBinder>& destChannelToken, int32_t displayId) override;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800129
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +0000130 base::Result<std::unique_ptr<InputChannel>> createInputChannel(
Garfield Tan15601662020-09-22 15:32:38 -0700131 const std::string& name) override;
chaviw98318de2021-05-19 16:45:23 -0500132 void setFocusedWindow(const android::gui::FocusRequest&) override;
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +0000133 base::Result<std::unique_ptr<InputChannel>> createInputMonitor(int32_t displayId,
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +0000134 const std::string& name,
135 int32_t pid) override;
136 status_t removeInputChannel(const sp<IBinder>& connectionToken) override;
137 status_t pilferPointers(const sp<IBinder>& token) override;
138 void requestPointerCapture(const sp<IBinder>& windowToken, bool enabled) override;
139 bool flushSensor(int deviceId, InputDeviceSensorType sensorType) override;
Christine Franksb768bb42021-11-29 12:11:31 -0800140 void setDisplayEligibilityForPointerCapture(int displayId, bool isEligible) override;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800141
chaviw09c8d2d2020-08-24 15:48:26 -0700142 std::array<uint8_t, 32> sign(const VerifiedInputEvent& event) const;
143
Vishnu Nair599f1412021-06-21 10:39:58 -0700144 void displayRemoved(int32_t displayId) override;
145
Siarhei Vishniakou18050092021-09-01 13:32:49 -0700146 // Public because it's also used by tests to simulate the WindowInfosListener callback
147 void onWindowInfosChanged(const std::vector<android::gui::WindowInfo>& windowInfos,
148 const std::vector<android::gui::DisplayInfo>& displayInfos);
chaviw15fab6f2021-06-07 14:15:52 -0500149
Arthur Hungdfd528e2021-12-08 13:23:04 +0000150 void cancelCurrentTouch() override;
151
Prabir Pradhan1376fcd2022-01-21 09:56:35 -0800152 // Public to allow tests to verify that a Monitor can get ANR.
153 void setMonitorDispatchingTimeoutForTest(std::chrono::nanoseconds timeout);
154
Michael Wrightd02c5b62014-02-10 15:10:22 -0800155private:
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700156 enum class DropReason {
157 NOT_DROPPED,
158 POLICY,
159 APP_SWITCH,
160 DISABLED,
161 BLOCKED,
162 STALE,
Prabir Pradhan99987712020-11-10 18:43:05 -0800163 NO_POINTER_CAPTURE,
Michael Wrightd02c5b62014-02-10 15:10:22 -0800164 };
165
Prabir Pradhan5a57cff2019-10-31 18:40:33 -0700166 std::unique_ptr<InputThread> mThread;
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700167
Michael Wrightd02c5b62014-02-10 15:10:22 -0800168 sp<InputDispatcherPolicyInterface> mPolicy;
Garfield Tane84e6f92019-08-29 17:28:41 -0700169 android::InputDispatcherConfiguration mConfig;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800170
Siarhei Vishniakou443ad902019-03-06 17:25:41 -0800171 std::mutex mLock;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800172
Siarhei Vishniakou443ad902019-03-06 17:25:41 -0800173 std::condition_variable mDispatcherIsAlive;
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -0800174 std::condition_variable mDispatcherEnteredIdle;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800175
176 sp<Looper> mLooper;
177
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700178 std::shared_ptr<EventEntry> mPendingEvent GUARDED_BY(mLock);
179 std::deque<std::shared_ptr<EventEntry>> mInboundQueue GUARDED_BY(mLock);
180 std::deque<std::shared_ptr<EventEntry>> mRecentQueue GUARDED_BY(mLock);
Prabir Pradhancef936d2021-07-21 16:17:52 +0000181
182 // A command entry captures state and behavior for an action to be performed in the
183 // dispatch loop after the initial processing has taken place. It is essentially
184 // a kind of continuation used to postpone sensitive policy interactions to a point
185 // in the dispatch loop where it is safe to release the lock (generally after finishing
186 // the critical parts of the dispatch cycle).
187 //
188 // The special thing about commands is that they can voluntarily release and reacquire
189 // the dispatcher lock at will. Initially when the command starts running, the
190 // dispatcher lock is held. However, if the command needs to call into the policy to
191 // do some work, it can release the lock, do the work, then reacquire the lock again
192 // before returning.
193 //
194 // This mechanism is a bit clunky but it helps to preserve the invariant that the dispatch
195 // never calls into the policy while holding its lock.
196 //
197 // Commands are called with the lock held, but they can release and re-acquire the lock from
198 // within.
199 using Command = std::function<void()>;
200 std::deque<Command> mCommandQueue GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800201
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800202 DropReason mLastDropReason GUARDED_BY(mLock);
Michael Wright3a981722015-06-10 15:26:13 +0100203
Garfield Tan1c7bc862020-01-28 13:24:04 -0800204 const IdGenerator mIdGenerator;
205
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700206 // With each iteration, InputDispatcher nominally processes one queued event,
207 // a timeout, or a response from an input consumer.
208 // This method should only be called on the input dispatcher's own thread.
209 void dispatchOnce();
210
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800211 void dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800212
213 // Enqueues an inbound event. Returns true if mLooper->wake() should be called.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700214 bool enqueueInboundEventLocked(std::unique_ptr<EventEntry> entry) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800215
216 // Cleans up input state when dropping an inbound event.
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700217 void dropInboundEventLocked(const EventEntry& entry, DropReason dropReason) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800218
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +0100219 // Enqueues a focus event.
Vishnu Nairad321cd2020-08-20 16:40:21 -0700220 void enqueueFocusEventLocked(const sp<IBinder>& windowToken, bool hasFocus,
Vishnu Nairc519ff72021-01-21 08:23:08 -0800221 const std::string& reason) REQUIRES(mLock);
arthurhungb89ccb02020-12-30 16:19:01 +0800222 // Enqueues a drag event.
chaviw98318de2021-05-19 16:45:23 -0500223 void enqueueDragEventLocked(const sp<android::gui::WindowInfoHandle>& windowToken,
224 bool isExiting, const MotionEntry& motionEntry) REQUIRES(mLock);
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +0100225
Michael Wrightd02c5b62014-02-10 15:10:22 -0800226 // Adds an event to a queue of recent events for debugging purposes.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700227 void addRecentEventLocked(std::shared_ptr<EventEntry> entry) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800228
229 // App switch latency optimization.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800230 bool mAppSwitchSawKeyDown GUARDED_BY(mLock);
231 nsecs_t mAppSwitchDueTime GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800232
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700233 bool isAppSwitchKeyEvent(const KeyEntry& keyEntry);
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800234 bool isAppSwitchPendingLocked() REQUIRES(mLock);
235 void resetPendingAppSwitchLocked(bool handled) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800236
Michael Wrightd02c5b62014-02-10 15:10:22 -0800237 // Blocked event latency optimization. Drops old events when the user intends
238 // to transfer focus to a new application.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700239 std::shared_ptr<EventEntry> mNextUnblockedEvent GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800240
Prabir Pradhand65552b2021-10-07 11:23:50 -0700241 sp<android::gui::WindowInfoHandle> findTouchedWindowAtLocked(
242 int32_t displayId, int32_t x, int32_t y, TouchState* touchState, bool isStylus = false,
243 bool addOutsideTargets = false, bool ignoreDragWindow = false) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800244
Prabir Pradhand65552b2021-10-07 11:23:50 -0700245 std::vector<sp<android::gui::WindowInfoHandle>> findTouchedSpyWindowsAtLocked(
246 int32_t displayId, int32_t x, int32_t y, bool isStylus) const REQUIRES(mLock);
Prabir Pradhan07e05b62021-11-19 03:57:24 -0800247
Siarhei Vishniakou7ae7afd2022-03-31 15:26:13 -0700248 sp<android::gui::WindowInfoHandle> findTouchedForegroundWindowLocked(int32_t displayId) const
249 REQUIRES(mLock);
250
Siarhei Vishniakouffaa2b12020-05-26 21:43:02 -0700251 sp<Connection> getConnectionLocked(const sp<IBinder>& inputConnectionToken) const
252 REQUIRES(mLock);
253
Siarhei Vishniakouad991402020-10-28 11:40:09 -0500254 std::string getConnectionNameLocked(const sp<IBinder>& connectionToken) const REQUIRES(mLock);
255
Siarhei Vishniakouffaa2b12020-05-26 21:43:02 -0700256 void removeConnectionLocked(const sp<Connection>& connection) REQUIRES(mLock);
257
Prabir Pradhan6a9a8312021-04-23 11:59:31 -0700258 template <typename T>
259 struct StrongPointerHash {
260 std::size_t operator()(const sp<T>& b) const { return std::hash<T*>{}(b.get()); }
Robert Carr5c8a0262018-10-03 16:30:44 -0700261 };
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +0000262
263 // All registered connections mapped by input channel token.
264 std::unordered_map<sp<IBinder>, sp<Connection>, StrongPointerHash<IBinder>> mConnectionsByToken
265 GUARDED_BY(mLock);
Robert Carr5c8a0262018-10-03 16:30:44 -0700266
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000267 // Find a monitor pid by the provided token.
268 std::optional<int32_t> findMonitorPidByTokenLocked(const sp<IBinder>& token) REQUIRES(mLock);
Michael Wright3dd60e22019-03-27 22:06:44 +0000269
Arthur Hung2fbf37f2018-09-13 18:16:41 +0800270 // Input channels that will receive a copy of all input events sent to the provided display.
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700271 std::unordered_map<int32_t, std::vector<Monitor>> mGlobalMonitorsByDisplay GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800272
Edgar Arriaga3d61bc12020-04-16 18:46:48 -0700273 const HmacKeyManager mHmacKeyManager;
274 const std::array<uint8_t, 32> getSignature(const MotionEntry& motionEntry,
275 const DispatchEntry& dispatchEntry) const;
276 const std::array<uint8_t, 32> getSignature(const KeyEntry& keyEntry,
277 const DispatchEntry& dispatchEntry) const;
Gang Wange9087892020-01-07 12:17:14 -0500278
Michael Wrightd02c5b62014-02-10 15:10:22 -0800279 // Event injection and synchronization.
Siarhei Vishniakou443ad902019-03-06 17:25:41 -0800280 std::condition_variable mInjectionResultAvailable;
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700281 void setInjectionResult(EventEntry& entry,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800282 android::os::InputEventInjectionResult injectionResult);
Prabir Pradhandaa2f142021-12-10 09:30:08 +0000283 void transformMotionEntryForInjectionLocked(MotionEntry&,
284 const ui::Transform& injectedTransform) const
285 REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800286
Siarhei Vishniakou443ad902019-03-06 17:25:41 -0800287 std::condition_variable mInjectionSyncFinished;
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700288 void incrementPendingForegroundDispatches(EventEntry& entry);
289 void decrementPendingForegroundDispatches(EventEntry& entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800290
291 // Key repeat tracking.
292 struct KeyRepeatState {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700293 std::shared_ptr<KeyEntry> lastKeyEntry; // or null if no repeat
Michael Wrightd02c5b62014-02-10 15:10:22 -0800294 nsecs_t nextRepeatTime;
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800295 } mKeyRepeatState GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800296
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800297 void resetKeyRepeatLocked() REQUIRES(mLock);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700298 std::shared_ptr<KeyEntry> synthesizeKeyRepeatLocked(nsecs_t currentTime) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800299
Michael Wright78f24442014-08-06 15:55:28 -0700300 // Key replacement tracking
301 struct KeyReplacement {
302 int32_t keyCode;
303 int32_t deviceId;
304 bool operator==(const KeyReplacement& rhs) const {
305 return keyCode == rhs.keyCode && deviceId == rhs.deviceId;
306 }
Siarhei Vishniakoubde3d9e2020-03-24 19:05:54 -0700307 };
308 struct KeyReplacementHash {
309 size_t operator()(const KeyReplacement& key) const {
310 return std::hash<int32_t>()(key.keyCode) ^ (std::hash<int32_t>()(key.deviceId) << 1);
Michael Wright78f24442014-08-06 15:55:28 -0700311 }
312 };
313 // Maps the key code replaced, device id tuple to the key code it was replaced with
Siarhei Vishniakoubde3d9e2020-03-24 19:05:54 -0700314 std::unordered_map<KeyReplacement, int32_t, KeyReplacementHash> mReplacedKeys GUARDED_BY(mLock);
Siarhei Vishniakou61fafdd2018-04-13 11:00:58 -0500315 // Process certain Meta + Key combinations
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700316 void accelerateMetaShortcuts(const int32_t deviceId, const int32_t action, int32_t& keyCode,
317 int32_t& metaState);
Michael Wright78f24442014-08-06 15:55:28 -0700318
Michael Wrightd02c5b62014-02-10 15:10:22 -0800319 // Deferred command processing.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800320 bool haveCommandsLocked() const REQUIRES(mLock);
Prabir Pradhancef936d2021-07-21 16:17:52 +0000321 bool runCommandsLockedInterruptable() REQUIRES(mLock);
322 void postCommandLocked(Command&& command) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800323
Prabir Pradhan1376fcd2022-01-21 09:56:35 -0800324 // The dispatching timeout to use for Monitors.
325 std::chrono::nanoseconds mMonitorDispatchingTimeout GUARDED_BY(mLock);
326
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700327 nsecs_t processAnrsLocked() REQUIRES(mLock);
Prabir Pradhan1376fcd2022-01-21 09:56:35 -0800328 std::chrono::nanoseconds getDispatchingTimeoutLocked(const sp<Connection>& connection)
329 REQUIRES(mLock);
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700330
Michael Wrightd02c5b62014-02-10 15:10:22 -0800331 // Input filter processing.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800332 bool shouldSendKeyToInputFilterLocked(const NotifyKeyArgs* args) REQUIRES(mLock);
333 bool shouldSendMotionToInputFilterLocked(const NotifyMotionArgs* args) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800334
335 // Inbound event processing.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800336 void drainInboundQueueLocked() REQUIRES(mLock);
337 void releasePendingEventLocked() REQUIRES(mLock);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700338 void releaseInboundEventLocked(std::shared_ptr<EventEntry> entry) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800339
340 // Dispatch state.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800341 bool mDispatchEnabled GUARDED_BY(mLock);
342 bool mDispatchFrozen GUARDED_BY(mLock);
343 bool mInputFilterEnabled GUARDED_BY(mLock);
Siarhei Vishniakouf3bc1aa2019-11-25 13:48:53 -0800344 bool mInTouchMode GUARDED_BY(mLock);
Bernardo Rufinoea97d182020-08-19 14:43:14 +0100345 float mMaximumObscuringOpacityForTouch GUARDED_BY(mLock);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800346 android::os::BlockUntrustedTouchesMode mBlockUntrustedTouchesMode GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800347
Siarhei Vishniakou18050092021-09-01 13:32:49 -0700348 class DispatcherWindowListener : public gui::WindowInfosListener {
349 public:
350 explicit DispatcherWindowListener(InputDispatcher& dispatcher) : mDispatcher(dispatcher){};
351 void onWindowInfosChanged(
352 const std::vector<android::gui::WindowInfo>& windowInfos,
353 const std::vector<android::gui::DisplayInfo>& displayInfos) override;
354
355 private:
356 InputDispatcher& mDispatcher;
357 };
358 sp<gui::WindowInfosListener> mWindowInfoListener;
359
Prabir Pradhan48f8cb92021-08-26 14:05:36 -0700360 std::unordered_map<int32_t /*displayId*/, std::vector<sp<android::gui::WindowInfoHandle>>>
chaviw98318de2021-05-19 16:45:23 -0500361 mWindowHandlesByDisplay GUARDED_BY(mLock);
Prabir Pradhan48f8cb92021-08-26 14:05:36 -0700362 std::unordered_map<int32_t /*displayId*/, android::gui::DisplayInfo> mDisplayInfos
363 GUARDED_BY(mLock);
chaviw98318de2021-05-19 16:45:23 -0500364 void setInputWindowsLocked(
365 const std::vector<sp<android::gui::WindowInfoHandle>>& inputWindowHandles,
366 int32_t displayId) REQUIRES(mLock);
Vishnu Nairad321cd2020-08-20 16:40:21 -0700367 // Get a reference to window handles by display, return an empty vector if not found.
chaviw98318de2021-05-19 16:45:23 -0500368 const std::vector<sp<android::gui::WindowInfoHandle>>& getWindowHandlesLocked(
369 int32_t displayId) const REQUIRES(mLock);
370 sp<android::gui::WindowInfoHandle> getWindowHandleLocked(
371 const sp<IBinder>& windowHandleToken) const REQUIRES(mLock);
Vishnu Nairad321cd2020-08-20 16:40:21 -0700372
373 // Same function as above, but faster. Since displayId is provided, this avoids the need
374 // to loop through all displays.
chaviw98318de2021-05-19 16:45:23 -0500375 sp<android::gui::WindowInfoHandle> getWindowHandleLocked(const sp<IBinder>& windowHandleToken,
376 int displayId) const REQUIRES(mLock);
377 sp<android::gui::WindowInfoHandle> getWindowHandleLocked(
378 const sp<android::gui::WindowInfoHandle>& windowHandle) const REQUIRES(mLock);
Siarhei Vishniakouce5ab082020-07-09 17:03:21 -0500379 std::shared_ptr<InputChannel> getInputChannelLocked(const sp<IBinder>& windowToken) const
380 REQUIRES(mLock);
chaviw98318de2021-05-19 16:45:23 -0500381 sp<android::gui::WindowInfoHandle> getFocusedWindowHandleLocked(int displayId) const
382 REQUIRES(mLock);
383 bool hasResponsiveConnectionLocked(android::gui::WindowInfoHandle& windowHandle) const
384 REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800385
Antonio Kantek7242d8b2021-08-05 16:07:20 -0700386 // Gets all the input targets (with their respective input channels) from the window handles
387 // passed as argument.
388 std::vector<InputTarget> getInputTargetsFromWindowHandlesLocked(
389 const std::vector<sp<android::gui::WindowInfoHandle>>& windowHandles) const
390 REQUIRES(mLock);
391
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -0700392 /*
393 * Validate and update InputWindowHandles for a given display.
394 */
395 void updateWindowHandlesForDisplayLocked(
chaviw98318de2021-05-19 16:45:23 -0500396 const std::vector<sp<android::gui::WindowInfoHandle>>& inputWindowHandles,
397 int32_t displayId) REQUIRES(mLock);
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -0700398
Siarhei Vishniakoubde3d9e2020-03-24 19:05:54 -0700399 std::unordered_map<int32_t, TouchState> mTouchStatesByDisplay GUARDED_BY(mLock);
arthurhung6d4bed92021-03-17 11:59:33 +0800400 std::unique_ptr<DragState> mDragState GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800401
Vishnu Nair599f1412021-06-21 10:39:58 -0700402 void setFocusedApplicationLocked(
403 int32_t displayId,
404 const std::shared_ptr<InputApplicationHandle>& inputApplicationHandle) REQUIRES(mLock);
Tiger Huang721e26f2018-07-24 22:26:19 +0800405 // Focused applications.
Chris Yea209fde2020-07-22 13:54:51 -0700406 std::unordered_map<int32_t, std::shared_ptr<InputApplicationHandle>>
407 mFocusedApplicationHandlesByDisplay GUARDED_BY(mLock);
Tiger Huang721e26f2018-07-24 22:26:19 +0800408
409 // Top focused display.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800410 int32_t mFocusedDisplayId GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800411
Vishnu Nairc519ff72021-01-21 08:23:08 -0800412 // Keeps track of the focused window per display and determines focus changes.
413 FocusResolver mFocusResolver GUARDED_BY(mLock);
Prabir Pradhan5cc1a692021-08-06 14:01:18 +0000414
415 // The enabled state of this request is true iff the focused window on the focused display has
416 // requested Pointer Capture. This request also contains the sequence number associated with the
417 // current request. The state of this variable should always be in sync with the state of
418 // Pointer Capture in the policy, and is only updated through setPointerCaptureLocked(request).
419 PointerCaptureRequest mCurrentPointerCaptureRequest GUARDED_BY(mLock);
Prabir Pradhan99987712020-11-10 18:43:05 -0800420
421 // The window token that has Pointer Capture.
422 // This should be in sync with PointerCaptureChangedEvents dispatched to the input channel.
423 sp<IBinder> mWindowTokenWithPointerCapture GUARDED_BY(mLock);
424
Christine Franksb768bb42021-11-29 12:11:31 -0800425 // Displays that are ineligible for pointer capture.
426 // TODO(b/214621487): Remove or move to a display flag.
427 std::vector<int32_t> mIneligibleDisplaysForPointerCapture GUARDED_BY(mLock);
428
Prabir Pradhan99987712020-11-10 18:43:05 -0800429 // Disable Pointer Capture as a result of loss of window focus.
430 void disablePointerCaptureForcedLocked() REQUIRES(mLock);
431
432 // Set the Pointer Capture state in the Policy.
Prabir Pradhan5cc1a692021-08-06 14:01:18 +0000433 void setPointerCaptureLocked(bool enable) REQUIRES(mLock);
Prabir Pradhan99987712020-11-10 18:43:05 -0800434
Michael Wrightd02c5b62014-02-10 15:10:22 -0800435 // Dispatcher state at time of last ANR.
Siarhei Vishniakoub1a16272020-05-06 16:09:19 -0700436 std::string mLastAnrState GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800437
Antonio Kantek48710e42022-03-24 14:19:30 -0700438 // The connection tokens of the channels that the user last interacted (used for debugging and
439 // when switching touch mode state).
Prabir Pradhan6a9a8312021-04-23 11:59:31 -0700440 std::unordered_set<sp<IBinder>, StrongPointerHash<IBinder>> mInteractionConnectionTokens
441 GUARDED_BY(mLock);
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +0000442 void updateInteractionTokensLocked(const EventEntry& entry,
443 const std::vector<InputTarget>& targets) REQUIRES(mLock);
444
Michael Wrightd02c5b62014-02-10 15:10:22 -0800445 // Dispatch inbound events.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700446 bool dispatchConfigurationChangedLocked(nsecs_t currentTime,
447 const ConfigurationChangedEntry& entry) REQUIRES(mLock);
448 bool dispatchDeviceResetLocked(nsecs_t currentTime, const DeviceResetEntry& entry)
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700449 REQUIRES(mLock);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700450 bool dispatchKeyLocked(nsecs_t currentTime, std::shared_ptr<KeyEntry> entry,
451 DropReason* dropReason, nsecs_t* nextWakeupTime) REQUIRES(mLock);
452 bool dispatchMotionLocked(nsecs_t currentTime, std::shared_ptr<MotionEntry> entry,
453 DropReason* dropReason, nsecs_t* nextWakeupTime) REQUIRES(mLock);
454 void dispatchFocusLocked(nsecs_t currentTime, std::shared_ptr<FocusEntry> entry)
455 REQUIRES(mLock);
Prabir Pradhan99987712020-11-10 18:43:05 -0800456 void dispatchPointerCaptureChangedLocked(
457 nsecs_t currentTime, const std::shared_ptr<PointerCaptureChangedEntry>& entry,
458 DropReason& dropReason) REQUIRES(mLock);
Antonio Kantek7242d8b2021-08-05 16:07:20 -0700459 void dispatchTouchModeChangeLocked(nsecs_t currentTime,
460 const std::shared_ptr<TouchModeEntry>& entry)
461 REQUIRES(mLock);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700462 void dispatchEventLocked(nsecs_t currentTime, std::shared_ptr<EventEntry> entry,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700463 const std::vector<InputTarget>& inputTargets) REQUIRES(mLock);
Prabir Pradhancef936d2021-07-21 16:17:52 +0000464 void dispatchSensorLocked(nsecs_t currentTime, const std::shared_ptr<SensorEntry>& entry,
Chris Yef59a2f42020-10-16 12:55:26 -0700465 DropReason* dropReason, nsecs_t* nextWakeupTime) REQUIRES(mLock);
arthurhungb89ccb02020-12-30 16:19:01 +0800466 void dispatchDragLocked(nsecs_t currentTime, std::shared_ptr<DragEntry> entry) REQUIRES(mLock);
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700467 void logOutboundKeyDetails(const char* prefix, const KeyEntry& entry);
468 void logOutboundMotionDetails(const char* prefix, const MotionEntry& entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800469
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700470 /**
471 * This field is set if there is no focused window, and we have an event that requires
472 * a focused window to be dispatched (for example, a KeyEvent).
473 * When this happens, we will wait until *mNoFocusedWindowTimeoutTime before
474 * dropping the event and raising an ANR for that application.
475 * This is useful if an application is slow to add a focused window.
476 */
477 std::optional<nsecs_t> mNoFocusedWindowTimeoutTime GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800478
Siarhei Vishniakou289e9242022-02-15 14:50:16 -0800479 // Amount of time to allow for an event to be dispatched (measured since its eventTime)
480 // before considering it stale and dropping it.
481 const std::chrono::nanoseconds mStaleEventTimeout;
482 bool isStaleEvent(nsecs_t currentTime, const EventEntry& entry);
483
Siarhei Vishniakoude1bc4a2020-05-26 22:39:43 -0700484 bool shouldPruneInboundQueueLocked(const MotionEntry& motionEntry) REQUIRES(mLock);
485
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700486 /**
487 * Time to stop waiting for the events to be processed while trying to dispatch a key.
488 * When this time expires, we just send the pending key event to the currently focused window,
489 * without waiting on other events to be processed first.
490 */
491 std::optional<nsecs_t> mKeyIsWaitingForEventsTimeout GUARDED_BY(mLock);
492 bool shouldWaitToSendKeyLocked(nsecs_t currentTime, const char* focusedWindowName)
493 REQUIRES(mLock);
494
495 /**
496 * The focused application at the time when no focused window was present.
497 * Used to raise an ANR when we have no focused window.
498 */
Chris Yea209fde2020-07-22 13:54:51 -0700499 std::shared_ptr<InputApplicationHandle> mAwaitedFocusedApplication GUARDED_BY(mLock);
Siarhei Vishniakouf56b2692020-09-08 19:43:33 -0500500 /**
501 * The displayId that the focused application is associated with.
502 */
503 int32_t mAwaitedApplicationDisplayId GUARDED_BY(mLock);
504 void processNoFocusedWindowAnrLocked() REQUIRES(mLock);
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700505
Vishnu Nair958da932020-08-21 17:12:37 -0700506 /**
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000507 * Tell policy about a window or a monitor that just became unresponsive. Starts ANR.
508 */
509 void processConnectionUnresponsiveLocked(const Connection& connection, std::string reason)
510 REQUIRES(mLock);
511 /**
512 * Tell policy about a window or a monitor that just became responsive.
513 */
514 void processConnectionResponsiveLocked(const Connection& connection) REQUIRES(mLock);
515
Prabir Pradhanedd96402022-02-15 01:46:16 -0800516 void sendWindowUnresponsiveCommandLocked(const sp<IBinder>& connectionToken,
517 std::optional<int32_t> pid, std::string reason)
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000518 REQUIRES(mLock);
Prabir Pradhanedd96402022-02-15 01:46:16 -0800519 void sendWindowResponsiveCommandLocked(const sp<IBinder>& connectionToken,
520 std::optional<int32_t> pid) REQUIRES(mLock);
Vishnu Nair958da932020-08-21 17:12:37 -0700521
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700522 // Optimization: AnrTracker is used to quickly find which connection is due for a timeout next.
523 // AnrTracker must be kept in-sync with all responsive connection.waitQueues.
524 // If a connection is not responsive, then the entries should not be added to the AnrTracker.
525 // Once a connection becomes unresponsive, its entries are removed from AnrTracker to
526 // prevent unneeded wakeups.
527 AnrTracker mAnrTracker GUARDED_BY(mLock);
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700528
Michael Wrightd02c5b62014-02-10 15:10:22 -0800529 // Contains the last window which received a hover event.
chaviw98318de2021-05-19 16:45:23 -0500530 sp<android::gui::WindowInfoHandle> mLastHoverWindowHandle GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800531
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700532 void cancelEventsForAnrLocked(const sp<Connection>& connection) REQUIRES(mLock);
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700533 // If a focused application changes, we should stop counting down the "no focused window" time,
534 // because we will have no way of knowing when the previous application actually added a window.
535 // This also means that we will miss cases like pulling down notification shade when the
536 // focused application does not have a focused window (no ANR will be raised if notification
537 // shade is pulled down while we are counting down the timeout).
538 void resetNoFocusedWindowTimeoutLocked() REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800539
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700540 int32_t getTargetDisplayId(const EventEntry& entry);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800541 android::os::InputEventInjectionResult findFocusedWindowTargetsLocked(
542 nsecs_t currentTime, const EventEntry& entry, std::vector<InputTarget>& inputTargets,
543 nsecs_t* nextWakeupTime) REQUIRES(mLock);
544 android::os::InputEventInjectionResult findTouchedWindowTargetsLocked(
545 nsecs_t currentTime, const MotionEntry& entry, std::vector<InputTarget>& inputTargets,
546 nsecs_t* nextWakeupTime, bool* outConflictingPointerActions) REQUIRES(mLock);
Prabir Pradhan0a99c922021-09-03 08:27:53 -0700547 std::vector<Monitor> selectResponsiveMonitorsLocked(
548 const std::vector<Monitor>& gestureMonitors) const REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800549
chaviw98318de2021-05-19 16:45:23 -0500550 void addWindowTargetLocked(const sp<android::gui::WindowInfoHandle>& windowHandle,
551 int32_t targetFlags, BitSet32 pointerIds,
552 std::vector<InputTarget>& inputTargets) REQUIRES(mLock);
Prabir Pradhan0a99c922021-09-03 08:27:53 -0700553 void addGlobalMonitoringTargetsLocked(std::vector<InputTarget>& inputTargets, int32_t displayId)
Prabir Pradhanb9b18502021-08-26 12:30:32 -0700554 REQUIRES(mLock);
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700555 void pokeUserActivityLocked(const EventEntry& eventEntry) REQUIRES(mLock);
arthurhungb89ccb02020-12-30 16:19:01 +0800556 // Enqueue a drag event if needed, and update the touch state.
557 // Uses findTouchedWindowTargetsLocked to make the decision
arthurhung6d4bed92021-03-17 11:59:33 +0800558 void addDragEventLocked(const MotionEntry& entry) REQUIRES(mLock);
559 void finishDragAndDrop(int32_t displayId, float x, float y) REQUIRES(mLock);
Bernardo Rufinoea97d182020-08-19 14:43:14 +0100560
561 struct TouchOcclusionInfo {
562 bool hasBlockingOcclusion;
563 float obscuringOpacity;
564 std::string obscuringPackage;
565 int32_t obscuringUid;
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +0000566 std::vector<std::string> debugInfo;
Bernardo Rufinoea97d182020-08-19 14:43:14 +0100567 };
568
chaviw98318de2021-05-19 16:45:23 -0500569 TouchOcclusionInfo computeTouchOcclusionInfoLocked(
570 const sp<android::gui::WindowInfoHandle>& windowHandle, int32_t x, int32_t y) const
571 REQUIRES(mLock);
Bernardo Rufinoea97d182020-08-19 14:43:14 +0100572 bool isTouchTrustedLocked(const TouchOcclusionInfo& occlusionInfo) const REQUIRES(mLock);
chaviw98318de2021-05-19 16:45:23 -0500573 bool isWindowObscuredAtPointLocked(const sp<android::gui::WindowInfoHandle>& windowHandle,
574 int32_t x, int32_t y) const REQUIRES(mLock);
575 bool isWindowObscuredLocked(const sp<android::gui::WindowInfoHandle>& windowHandle) const
576 REQUIRES(mLock);
577 std::string dumpWindowForTouchOcclusion(const android::gui::WindowInfo* info,
578 bool isTouchWindow) const;
Siarhei Vishniakou234129c2020-10-22 22:28:12 -0500579 std::string getApplicationWindowLabel(const InputApplicationHandle* applicationHandle,
chaviw98318de2021-05-19 16:45:23 -0500580 const sp<android::gui::WindowInfoHandle>& windowHandle);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800581
Vishnu Nair062a8672021-09-03 16:07:44 -0700582 bool shouldDropInput(const EventEntry& entry,
583 const sp<android::gui::WindowInfoHandle>& windowHandle) const
584 REQUIRES(mLock);
585
Michael Wrightd02c5b62014-02-10 15:10:22 -0800586 // Manage the dispatch cycle for a single connection.
587 // These methods are deliberately not Interruptible because doing all of the work
588 // with the mutex held makes it easier to ensure that connection invariants are maintained.
589 // If needed, the methods post commands to run later once the critical bits are done.
590 void prepareDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700591 std::shared_ptr<EventEntry>, const InputTarget& inputTarget)
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700592 REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800593 void enqueueDispatchEntriesLocked(nsecs_t currentTime, const sp<Connection>& connection,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700594 std::shared_ptr<EventEntry>, const InputTarget& inputTarget)
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700595 REQUIRES(mLock);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700596 void enqueueDispatchEntryLocked(const sp<Connection>& connection, std::shared_ptr<EventEntry>,
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -0800597 const InputTarget& inputTarget, int32_t dispatchMode)
chaviw8c9cf542019-03-25 13:02:48 -0700598 REQUIRES(mLock);
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800599 void startDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection)
600 REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800601 void finishDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,
Siarhei Vishniakou3531ae72021-02-02 12:12:27 -1000602 uint32_t seq, bool handled, nsecs_t consumeTime) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800603 void abortBrokenDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700604 bool notify) REQUIRES(mLock);
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -0700605 void drainDispatchQueue(std::deque<DispatchEntry*>& queue);
Siarhei Vishniakou62683e82019-03-06 17:59:56 -0800606 void releaseDispatchEntry(DispatchEntry* dispatchEntry);
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +0000607 int handleReceiveCallback(int events, sp<IBinder> connectionToken);
chaviw8c9cf542019-03-25 13:02:48 -0700608 // The action sent should only be of type AMOTION_EVENT_*
chaviwfd6d3512019-03-25 13:23:49 -0700609 void dispatchPointerDownOutsideFocus(uint32_t source, int32_t action,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700610 const sp<IBinder>& newToken) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800611
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700612 void synthesizeCancelationEventsForAllConnectionsLocked(const CancelationOptions& options)
613 REQUIRES(mLock);
614 void synthesizeCancelationEventsForMonitorsLocked(const CancelationOptions& options)
615 REQUIRES(mLock);
Siarhei Vishniakouce5ab082020-07-09 17:03:21 -0500616 void synthesizeCancelationEventsForInputChannelLocked(
617 const std::shared_ptr<InputChannel>& channel, const CancelationOptions& options)
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700618 REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800619 void synthesizeCancelationEventsForConnectionLocked(const sp<Connection>& connection,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700620 const CancelationOptions& options)
621 REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800622
Svet Ganov5d3bc372020-01-26 23:11:07 -0800623 void synthesizePointerDownEventsForConnectionLocked(const sp<Connection>& connection)
624 REQUIRES(mLock);
625
Michael Wrightd02c5b62014-02-10 15:10:22 -0800626 // Splitting motion events across windows.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700627 std::unique_ptr<MotionEntry> splitMotionEvent(const MotionEntry& originalMotionEntry,
628 BitSet32 pointerIds);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800629
630 // Reset and drop everything the dispatcher is doing.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800631 void resetAndDropEverythingLocked(const char* reason) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800632
633 // Dump state.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800634 void dumpDispatchStateLocked(std::string& dump) REQUIRES(mLock);
Michael Wright3dd60e22019-03-27 22:06:44 +0000635 void dumpMonitors(std::string& dump, const std::vector<Monitor>& monitors);
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800636 void logDispatchStateLocked() REQUIRES(mLock);
Prabir Pradhan99987712020-11-10 18:43:05 -0800637 std::string dumpPointerCaptureStateLocked() REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800638
639 // Registration.
Siarhei Vishniakouadefc3e2020-09-02 22:28:29 -0500640 void removeMonitorChannelLocked(const sp<IBinder>& connectionToken) REQUIRES(mLock);
Garfield Tan15601662020-09-22 15:32:38 -0700641 status_t removeInputChannelLocked(const sp<IBinder>& connectionToken, bool notify)
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800642 REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800643
644 // Interesting events that we might like to log or tell the framework about.
Prabir Pradhancef936d2021-07-21 16:17:52 +0000645 void doDispatchCycleFinishedCommand(nsecs_t finishTime, const sp<Connection>& connection,
646 uint32_t seq, bool handled, nsecs_t consumeTime)
Siarhei Vishniakou3531ae72021-02-02 12:12:27 -1000647 REQUIRES(mLock);
Prabir Pradhancef936d2021-07-21 16:17:52 +0000648 void doInterceptKeyBeforeDispatchingCommand(const sp<IBinder>& focusedWindowToken,
649 KeyEntry& entry) REQUIRES(mLock);
Vishnu Nairc519ff72021-01-21 08:23:08 -0800650 void onFocusChangedLocked(const FocusResolver::FocusChanges& changes) REQUIRES(mLock);
Prabir Pradhancef936d2021-07-21 16:17:52 +0000651 void sendFocusChangedCommandLocked(const sp<IBinder>& oldToken, const sp<IBinder>& newToken)
Vishnu Nairad321cd2020-08-20 16:40:21 -0700652 REQUIRES(mLock);
Prabir Pradhancef936d2021-07-21 16:17:52 +0000653 void sendDropWindowCommandLocked(const sp<IBinder>& token, float x, float y) REQUIRES(mLock);
654 void sendUntrustedTouchCommandLocked(const std::string& obscuringPackage) REQUIRES(mLock);
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000655 void onAnrLocked(const sp<Connection>& connection) REQUIRES(mLock);
Siarhei Vishniakou234129c2020-10-22 22:28:12 -0500656 void onAnrLocked(std::shared_ptr<InputApplicationHandle> application) REQUIRES(mLock);
chaviw98318de2021-05-19 16:45:23 -0500657 void updateLastAnrStateLocked(const sp<android::gui::WindowInfoHandle>& window,
658 const std::string& reason) REQUIRES(mLock);
Siarhei Vishniakou234129c2020-10-22 22:28:12 -0500659 void updateLastAnrStateLocked(const InputApplicationHandle& application,
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700660 const std::string& reason) REQUIRES(mLock);
661 void updateLastAnrStateLocked(const std::string& windowLabel, const std::string& reason)
662 REQUIRES(mLock);
Prabir Pradhancef936d2021-07-21 16:17:52 +0000663 bool afterKeyEventLockedInterruptable(const sp<Connection>& connection,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700664 DispatchEntry* dispatchEntry, KeyEntry& keyEntry,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700665 bool handled) REQUIRES(mLock);
Prabir Pradhancef936d2021-07-21 16:17:52 +0000666 bool afterMotionEventLockedInterruptable(const sp<Connection>& connection,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700667 DispatchEntry* dispatchEntry, MotionEntry& motionEntry,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700668 bool handled) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800669
Arthur Hungabbb9d82021-09-01 14:52:30 +0000670 // Find touched state and touched window by token.
671 std::pair<TouchState*, TouchedWindow*> findTouchStateAndWindowLocked(const sp<IBinder>& token)
672 REQUIRES(mLock);
673
Michael Wrightd02c5b62014-02-10 15:10:22 -0800674 // Statistics gathering.
Siarhei Vishniakoua04181f2021-03-26 05:56:49 +0000675 LatencyAggregator mLatencyAggregator GUARDED_BY(mLock);
Siarhei Vishniakouf2652122021-03-05 21:39:46 +0000676 LatencyTracker mLatencyTracker GUARDED_BY(mLock);
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800677 void traceInboundQueueLengthLocked() REQUIRES(mLock);
Siarhei Vishniakou060a7272021-02-03 19:40:10 +0000678 void traceOutboundQueueLength(const Connection& connection);
679 void traceWaitQueueLength(const Connection& connection);
Prabir Pradhanf93562f2018-11-29 12:13:37 -0800680
Antonio Kantek48710e42022-03-24 14:19:30 -0700681 // Check window ownership
682 bool focusedWindowIsOwnedByLocked(int32_t pid, int32_t uid) REQUIRES(mLock);
683 bool recentWindowsAreOwnedByLocked(int32_t pid, int32_t uid) REQUIRES(mLock);
684
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