blob: df0be99854d99be1ac62af44c41662d8e9503880 [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"
22#include "Entry.h"
23#include "InjectionState.h"
24#include "InputDispatcherConfiguration.h"
25#include "InputDispatcherInterface.h"
26#include "InputDispatcherPolicyInterface.h"
27#include "InputState.h"
28#include "InputTarget.h"
Prabir Pradhan5a57cff2019-10-31 18:40:33 -070029#include "InputThread.h"
Garfield Tane84e6f92019-08-29 17:28:41 -070030#include "Monitor.h"
31#include "TouchState.h"
32#include "TouchedWindow.h"
33
chaviw09c8d2d2020-08-24 15:48:26 -070034#include <attestation/HmacKeyManager.h>
Siarhei Vishniakou2508b872020-12-03 16:33:53 -100035#include <com/android/internal/compat/IPlatformCompatNative.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080036#include <input/Input.h>
Robert Carr3720ed02018-08-08 16:08:27 -070037#include <input/InputApplication.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080038#include <input/InputTransport.h>
Robert Carr3720ed02018-08-08 16:08:27 -070039#include <input/InputWindow.h>
Siarhei Vishniakoude4bf152019-08-16 11:12:52 -050040#include <input/LatencyStatistics.h>
Garfield Tane84e6f92019-08-29 17:28:41 -070041#include <limits.h>
42#include <stddef.h>
Michael Wright3dd60e22019-03-27 22:06:44 +000043#include <ui/Region.h>
Garfield Tane84e6f92019-08-29 17:28:41 -070044#include <unistd.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080045#include <utils/BitSet.h>
Garfield Tan0fc2fa72019-08-29 17:22:15 -070046#include <utils/Looper.h>
47#include <utils/RefBase.h>
48#include <utils/Timers.h>
49#include <utils/threads.h>
50#include <condition_variable>
Garfield Tane84e6f92019-08-29 17:28:41 -070051#include <deque>
Garfield Tan0fc2fa72019-08-29 17:22:15 -070052#include <optional>
Robert Carr5c8a0262018-10-03 16:30:44 -070053#include <unordered_map>
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +000054#include <unordered_set>
Michael Wrightd02c5b62014-02-10 15:10:22 -080055
Garfield Tane84e6f92019-08-29 17:28:41 -070056#include <InputListener.h>
57#include <InputReporterInterface.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080058
Garfield Tane84e6f92019-08-29 17:28:41 -070059namespace android::inputdispatcher {
Michael Wrightd02c5b62014-02-10 15:10:22 -080060
Garfield Tane84e6f92019-08-29 17:28:41 -070061class Connection;
Michael Wrightd02c5b62014-02-10 15:10:22 -080062
63/* Dispatches events to input targets. Some functions of the input dispatcher, such as
64 * identifying input targets, are controlled by a separate policy object.
65 *
66 * IMPORTANT INVARIANT:
67 * Because the policy can potentially block or cause re-entrance into the input dispatcher,
68 * the input dispatcher never calls into the policy while holding its internal locks.
69 * The implementation is also carefully designed to recover from scenarios such as an
70 * input channel becoming unregistered while identifying input targets or processing timeouts.
71 *
72 * Methods marked 'Locked' must be called with the lock acquired.
73 *
74 * Methods marked 'LockedInterruptible' must be called with the lock acquired but
75 * may during the course of their execution release the lock, call into the policy, and
76 * then reacquire the lock. The caller is responsible for recovering gracefully.
77 *
78 * A 'LockedInterruptible' method may called a 'Locked' method, but NOT vice-versa.
79 */
Garfield Tane84e6f92019-08-29 17:28:41 -070080class InputDispatcher : public android::InputDispatcherInterface {
Michael Wrightd02c5b62014-02-10 15:10:22 -080081protected:
82 virtual ~InputDispatcher();
83
84public:
85 explicit InputDispatcher(const sp<InputDispatcherPolicyInterface>& policy);
86
Michael Wright3dd60e22019-03-27 22:06:44 +000087 virtual void dump(std::string& dump) override;
88 virtual void monitor() override;
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -080089 virtual bool waitForIdle() override;
Prabir Pradhan3608aad2019-10-02 17:08:26 -070090 virtual status_t start() override;
91 virtual status_t stop() override;
Michael Wrightd02c5b62014-02-10 15:10:22 -080092
Michael Wright3dd60e22019-03-27 22:06:44 +000093 virtual void notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args) override;
94 virtual void notifyKey(const NotifyKeyArgs* args) override;
95 virtual void notifyMotion(const NotifyMotionArgs* args) override;
96 virtual void notifySwitch(const NotifySwitchArgs* args) override;
Chris Yef59a2f42020-10-16 12:55:26 -070097 virtual void notifySensor(const NotifySensorArgs* args) override;
Michael Wright3dd60e22019-03-27 22:06:44 +000098 virtual void notifyDeviceReset(const NotifyDeviceResetArgs* args) override;
Prabir Pradhan7e186182020-11-10 13:56:45 -080099 virtual void notifyPointerCaptureChanged(const NotifyPointerCaptureChangedArgs* args) override;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800100
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800101 virtual android::os::InputEventInjectionResult injectInputEvent(
102 const InputEvent* event, int32_t injectorPid, int32_t injectorUid,
103 android::os::InputEventInjectionSync syncMode, std::chrono::milliseconds timeout,
104 uint32_t policyFlags) override;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800105
Siarhei Vishniakou54d3e182020-01-15 17:38:38 -0800106 virtual std::unique_ptr<VerifiedInputEvent> verifyInputEvent(const InputEvent& event) override;
107
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700108 virtual void setInputWindows(
Arthur Hung72d8dc32020-03-28 00:48:39 +0000109 const std::unordered_map<int32_t, std::vector<sp<InputWindowHandle>>>&
110 handlesPerDisplay) override;
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700111 virtual void setFocusedApplication(
Chris Yea209fde2020-07-22 13:54:51 -0700112 int32_t displayId,
113 const std::shared_ptr<InputApplicationHandle>& inputApplicationHandle) override;
Michael Wright3dd60e22019-03-27 22:06:44 +0000114 virtual void setFocusedDisplay(int32_t displayId) override;
115 virtual void setInputDispatchMode(bool enabled, bool frozen) override;
116 virtual void setInputFilterEnabled(bool enabled) override;
Siarhei Vishniakouf3bc1aa2019-11-25 13:48:53 -0800117 virtual void setInTouchMode(bool inTouchMode) override;
Bernardo Rufinoea97d182020-08-19 14:43:14 +0100118 virtual void setMaximumObscuringOpacityForTouch(float opacity) override;
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800119 virtual void setBlockUntrustedTouchesMode(android::os::BlockUntrustedTouchesMode mode) override;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800120
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700121 virtual bool transferTouchFocus(const sp<IBinder>& fromToken,
122 const sp<IBinder>& toToken) override;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800123
Garfield Tan15601662020-09-22 15:32:38 -0700124 virtual base::Result<std::unique_ptr<InputChannel>> createInputChannel(
125 const std::string& name) override;
Vishnu Naire798b472020-07-23 13:52:21 -0700126 virtual void setFocusedWindow(const FocusRequest&) override;
Siarhei Vishniakou58cfc602020-12-14 23:21:30 +0000127 virtual base::Result<std::unique_ptr<InputChannel>> createInputMonitor(int32_t displayId,
128 bool isGestureMonitor,
129 const std::string& name,
130 int32_t pid) override;
Garfield Tan15601662020-09-22 15:32:38 -0700131 virtual status_t removeInputChannel(const sp<IBinder>& connectionToken) override;
Michael Wright3dd60e22019-03-27 22:06:44 +0000132 virtual status_t pilferPointers(const sp<IBinder>& token) override;
Prabir Pradhan99987712020-11-10 18:43:05 -0800133 virtual void requestPointerCapture(const sp<IBinder>& windowToken, bool enabled) override;
Chris Yef59a2f42020-10-16 12:55:26 -0700134 virtual bool flushSensor(int deviceId, InputDeviceSensorType sensorType) override;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800135
chaviw09c8d2d2020-08-24 15:48:26 -0700136 std::array<uint8_t, 32> sign(const VerifiedInputEvent& event) const;
137
Michael Wrightd02c5b62014-02-10 15:10:22 -0800138private:
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700139 enum class DropReason {
140 NOT_DROPPED,
141 POLICY,
142 APP_SWITCH,
143 DISABLED,
144 BLOCKED,
145 STALE,
Prabir Pradhan99987712020-11-10 18:43:05 -0800146 NO_POINTER_CAPTURE,
Michael Wrightd02c5b62014-02-10 15:10:22 -0800147 };
148
Vishnu Nair958da932020-08-21 17:12:37 -0700149 enum class FocusResult {
150 OK,
151 NO_WINDOW,
152 NOT_FOCUSABLE,
153 NOT_VISIBLE,
154 };
155 static const char* typeToString(FocusResult result);
156
Prabir Pradhan5a57cff2019-10-31 18:40:33 -0700157 std::unique_ptr<InputThread> mThread;
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700158
Michael Wrightd02c5b62014-02-10 15:10:22 -0800159 sp<InputDispatcherPolicyInterface> mPolicy;
Garfield Tane84e6f92019-08-29 17:28:41 -0700160 android::InputDispatcherConfiguration mConfig;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800161
Siarhei Vishniakou443ad902019-03-06 17:25:41 -0800162 std::mutex mLock;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800163
Siarhei Vishniakou443ad902019-03-06 17:25:41 -0800164 std::condition_variable mDispatcherIsAlive;
Siarhei Vishniakou2bfa9052019-11-21 18:10:54 -0800165 std::condition_variable mDispatcherEnteredIdle;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800166
167 sp<Looper> mLooper;
168
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700169 std::shared_ptr<EventEntry> mPendingEvent GUARDED_BY(mLock);
170 std::deque<std::shared_ptr<EventEntry>> mInboundQueue GUARDED_BY(mLock);
171 std::deque<std::shared_ptr<EventEntry>> mRecentQueue GUARDED_BY(mLock);
Siarhei Vishniakoue7c94b92019-07-29 09:17:54 -0700172 std::deque<std::unique_ptr<CommandEntry>> mCommandQueue GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800173
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800174 DropReason mLastDropReason GUARDED_BY(mLock);
Michael Wright3a981722015-06-10 15:26:13 +0100175
Garfield Tan1c7bc862020-01-28 13:24:04 -0800176 const IdGenerator mIdGenerator;
177
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700178 // With each iteration, InputDispatcher nominally processes one queued event,
179 // a timeout, or a response from an input consumer.
180 // This method should only be called on the input dispatcher's own thread.
181 void dispatchOnce();
182
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800183 void dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800184
185 // Enqueues an inbound event. Returns true if mLooper->wake() should be called.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700186 bool enqueueInboundEventLocked(std::unique_ptr<EventEntry> entry) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800187
188 // Cleans up input state when dropping an inbound event.
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700189 void dropInboundEventLocked(const EventEntry& entry, DropReason dropReason) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800190
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +0100191 // Enqueues a focus event.
Vishnu Nairad321cd2020-08-20 16:40:21 -0700192 void enqueueFocusEventLocked(const sp<IBinder>& windowToken, bool hasFocus,
Vishnu Nair7d3d00d2020-08-03 11:20:42 -0700193 std::string_view reason) REQUIRES(mLock);
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +0100194
Michael Wrightd02c5b62014-02-10 15:10:22 -0800195 // Adds an event to a queue of recent events for debugging purposes.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700196 void addRecentEventLocked(std::shared_ptr<EventEntry> entry) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800197
198 // App switch latency optimization.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800199 bool mAppSwitchSawKeyDown GUARDED_BY(mLock);
200 nsecs_t mAppSwitchDueTime GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800201
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700202 bool isAppSwitchKeyEvent(const KeyEntry& keyEntry);
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800203 bool isAppSwitchPendingLocked() REQUIRES(mLock);
204 void resetPendingAppSwitchLocked(bool handled) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800205
Michael Wrightd02c5b62014-02-10 15:10:22 -0800206 // Blocked event latency optimization. Drops old events when the user intends
207 // to transfer focus to a new application.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700208 std::shared_ptr<EventEntry> mNextUnblockedEvent GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800209
Tiger Huang85b8c5e2019-01-17 18:34:54 +0800210 sp<InputWindowHandle> findTouchedWindowAtLocked(int32_t displayId, int32_t x, int32_t y,
Siarhei Vishniakou1ea3cf12020-03-24 19:50:03 -0700211 TouchState* touchState,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700212 bool addOutsideTargets = false,
213 bool addPortalWindows = false) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800214
215 // All registered connections mapped by channel file descriptor.
Siarhei Vishniakou146ecfd2019-07-29 16:04:31 -0700216 std::unordered_map<int, sp<Connection>> mConnectionsByFd GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800217
Siarhei Vishniakouffaa2b12020-05-26 21:43:02 -0700218 sp<Connection> getConnectionLocked(const sp<IBinder>& inputConnectionToken) const
219 REQUIRES(mLock);
220
Siarhei Vishniakouad991402020-10-28 11:40:09 -0500221 std::string getConnectionNameLocked(const sp<IBinder>& connectionToken) const REQUIRES(mLock);
222
Siarhei Vishniakouffaa2b12020-05-26 21:43:02 -0700223 void removeConnectionLocked(const sp<Connection>& connection) REQUIRES(mLock);
224
Robert Carr5c8a0262018-10-03 16:30:44 -0700225 struct IBinderHash {
226 std::size_t operator()(const sp<IBinder>& b) const {
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700227 return std::hash<IBinder*>{}(b.get());
Robert Carr5c8a0262018-10-03 16:30:44 -0700228 }
229 };
Siarhei Vishniakouce5ab082020-07-09 17:03:21 -0500230 std::unordered_map<sp<IBinder>, std::shared_ptr<InputChannel>, IBinderHash>
231 mInputChannelsByToken GUARDED_BY(mLock);
Robert Carr5c8a0262018-10-03 16:30:44 -0700232
Michael Wright3dd60e22019-03-27 22:06:44 +0000233 // Finds the display ID of the gesture monitor identified by the provided token.
234 std::optional<int32_t> findGestureMonitorDisplayByTokenLocked(const sp<IBinder>& token)
235 REQUIRES(mLock);
236
Arthur Hung2fbf37f2018-09-13 18:16:41 +0800237 // Input channels that will receive a copy of all input events sent to the provided display.
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700238 std::unordered_map<int32_t, std::vector<Monitor>> mGlobalMonitorsByDisplay GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800239
Michael Wright3dd60e22019-03-27 22:06:44 +0000240 // Input channels that will receive pointer events that start within the corresponding display.
241 // These are a bit special when compared to global monitors since they'll cause gesture streams
242 // to continue even when there isn't a touched window,and have the ability to steal the rest of
243 // the pointer stream in order to claim it for a system gesture.
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700244 std::unordered_map<int32_t, std::vector<Monitor>> mGestureMonitorsByDisplay GUARDED_BY(mLock);
Michael Wright3dd60e22019-03-27 22:06:44 +0000245
Edgar Arriaga3d61bc12020-04-16 18:46:48 -0700246 const HmacKeyManager mHmacKeyManager;
247 const std::array<uint8_t, 32> getSignature(const MotionEntry& motionEntry,
248 const DispatchEntry& dispatchEntry) const;
249 const std::array<uint8_t, 32> getSignature(const KeyEntry& keyEntry,
250 const DispatchEntry& dispatchEntry) const;
Gang Wange9087892020-01-07 12:17:14 -0500251
Michael Wrightd02c5b62014-02-10 15:10:22 -0800252 // Event injection and synchronization.
Siarhei Vishniakou443ad902019-03-06 17:25:41 -0800253 std::condition_variable mInjectionResultAvailable;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800254 bool hasInjectionPermission(int32_t injectorPid, int32_t injectorUid);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700255 void setInjectionResult(EventEntry& entry,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800256 android::os::InputEventInjectionResult injectionResult);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800257
Siarhei Vishniakou443ad902019-03-06 17:25:41 -0800258 std::condition_variable mInjectionSyncFinished;
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700259 void incrementPendingForegroundDispatches(EventEntry& entry);
260 void decrementPendingForegroundDispatches(EventEntry& entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800261
262 // Key repeat tracking.
263 struct KeyRepeatState {
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700264 std::shared_ptr<KeyEntry> lastKeyEntry; // or null if no repeat
Michael Wrightd02c5b62014-02-10 15:10:22 -0800265 nsecs_t nextRepeatTime;
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800266 } mKeyRepeatState GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800267
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800268 void resetKeyRepeatLocked() REQUIRES(mLock);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700269 std::shared_ptr<KeyEntry> synthesizeKeyRepeatLocked(nsecs_t currentTime) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800270
Michael Wright78f24442014-08-06 15:55:28 -0700271 // Key replacement tracking
272 struct KeyReplacement {
273 int32_t keyCode;
274 int32_t deviceId;
275 bool operator==(const KeyReplacement& rhs) const {
276 return keyCode == rhs.keyCode && deviceId == rhs.deviceId;
277 }
Siarhei Vishniakoubde3d9e2020-03-24 19:05:54 -0700278 };
279 struct KeyReplacementHash {
280 size_t operator()(const KeyReplacement& key) const {
281 return std::hash<int32_t>()(key.keyCode) ^ (std::hash<int32_t>()(key.deviceId) << 1);
Michael Wright78f24442014-08-06 15:55:28 -0700282 }
283 };
284 // Maps the key code replaced, device id tuple to the key code it was replaced with
Siarhei Vishniakoubde3d9e2020-03-24 19:05:54 -0700285 std::unordered_map<KeyReplacement, int32_t, KeyReplacementHash> mReplacedKeys GUARDED_BY(mLock);
Siarhei Vishniakou61fafdd2018-04-13 11:00:58 -0500286 // Process certain Meta + Key combinations
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700287 void accelerateMetaShortcuts(const int32_t deviceId, const int32_t action, int32_t& keyCode,
288 int32_t& metaState);
Michael Wright78f24442014-08-06 15:55:28 -0700289
Michael Wrightd02c5b62014-02-10 15:10:22 -0800290 // Deferred command processing.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800291 bool haveCommandsLocked() const REQUIRES(mLock);
292 bool runCommandsLockedInterruptible() REQUIRES(mLock);
Siarhei Vishniakoue7c94b92019-07-29 09:17:54 -0700293 void postCommandLocked(std::unique_ptr<CommandEntry> commandEntry) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800294
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700295 nsecs_t processAnrsLocked() REQUIRES(mLock);
Siarhei Vishniakou70622952020-07-30 11:17:23 -0500296 std::chrono::nanoseconds getDispatchingTimeoutLocked(const sp<IBinder>& token) REQUIRES(mLock);
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700297
Michael Wrightd02c5b62014-02-10 15:10:22 -0800298 // Input filter processing.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800299 bool shouldSendKeyToInputFilterLocked(const NotifyKeyArgs* args) REQUIRES(mLock);
300 bool shouldSendMotionToInputFilterLocked(const NotifyMotionArgs* args) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800301
302 // Inbound event processing.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800303 void drainInboundQueueLocked() REQUIRES(mLock);
304 void releasePendingEventLocked() REQUIRES(mLock);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700305 void releaseInboundEventLocked(std::shared_ptr<EventEntry> entry) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800306
307 // Dispatch state.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800308 bool mDispatchEnabled GUARDED_BY(mLock);
309 bool mDispatchFrozen GUARDED_BY(mLock);
310 bool mInputFilterEnabled GUARDED_BY(mLock);
Siarhei Vishniakouf3bc1aa2019-11-25 13:48:53 -0800311 bool mInTouchMode GUARDED_BY(mLock);
Bernardo Rufinoea97d182020-08-19 14:43:14 +0100312 float mMaximumObscuringOpacityForTouch GUARDED_BY(mLock);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800313 android::os::BlockUntrustedTouchesMode mBlockUntrustedTouchesMode GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800314
Arthur Hung7c3ae9c2019-03-11 11:23:03 +0800315 std::unordered_map<int32_t, std::vector<sp<InputWindowHandle>>> mWindowHandlesByDisplay
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800316 GUARDED_BY(mLock);
Arthur Hung72d8dc32020-03-28 00:48:39 +0000317 void setInputWindowsLocked(const std::vector<sp<InputWindowHandle>>& inputWindowHandles,
318 int32_t displayId) REQUIRES(mLock);
Vishnu Nairad321cd2020-08-20 16:40:21 -0700319 // Get a reference to window handles by display, return an empty vector if not found.
320 const std::vector<sp<InputWindowHandle>>& getWindowHandlesLocked(int32_t displayId) const
Arthur Hung7c3ae9c2019-03-11 11:23:03 +0800321 REQUIRES(mLock);
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800322 sp<InputWindowHandle> getWindowHandleLocked(const sp<IBinder>& windowHandleToken) const
323 REQUIRES(mLock);
Vishnu Nairad321cd2020-08-20 16:40:21 -0700324
325 // Same function as above, but faster. Since displayId is provided, this avoids the need
326 // to loop through all displays.
327 sp<InputWindowHandle> getWindowHandleLocked(const sp<IBinder>& windowHandleToken,
328 int displayId) const REQUIRES(mLock);
Siarhei Vishniakouce5ab082020-07-09 17:03:21 -0500329 std::shared_ptr<InputChannel> getInputChannelLocked(const sp<IBinder>& windowToken) const
330 REQUIRES(mLock);
Vishnu Nairad321cd2020-08-20 16:40:21 -0700331 sp<InputWindowHandle> getFocusedWindowHandleLocked(int displayId) const REQUIRES(mLock);
Mady Mellor017bcd12020-06-23 19:12:00 +0000332 bool hasWindowHandleLocked(const sp<InputWindowHandle>& windowHandle) const REQUIRES(mLock);
Siarhei Vishniakoua2862a02020-07-20 16:36:46 -0500333 bool hasResponsiveConnectionLocked(InputWindowHandle& windowHandle) const REQUIRES(mLock);
Vishnu Nair958da932020-08-21 17:12:37 -0700334 FocusResult handleFocusRequestLocked(const FocusRequest&) REQUIRES(mLock);
335 FocusResult checkTokenFocusableLocked(const sp<IBinder>& token, int32_t displayId) const
336 REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800337
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -0700338 /*
339 * Validate and update InputWindowHandles for a given display.
340 */
341 void updateWindowHandlesForDisplayLocked(
342 const std::vector<sp<InputWindowHandle>>& inputWindowHandles, int32_t displayId)
343 REQUIRES(mLock);
344
Vishnu Nairad321cd2020-08-20 16:40:21 -0700345 // Focus tracking for keys, trackball, etc. A window token can be associated with one or more
346 // InputWindowHandles. If a window is mirrored, the window and its mirror will share the same
347 // token. Focus is tracked by the token per display and the events are dispatched to the
348 // channel associated by this token.
349 std::unordered_map<int32_t, sp<IBinder>> mFocusedWindowTokenByDisplay GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800350
Siarhei Vishniakoubde3d9e2020-03-24 19:05:54 -0700351 std::unordered_map<int32_t, TouchState> mTouchStatesByDisplay GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800352
Tiger Huang721e26f2018-07-24 22:26:19 +0800353 // Focused applications.
Chris Yea209fde2020-07-22 13:54:51 -0700354 std::unordered_map<int32_t, std::shared_ptr<InputApplicationHandle>>
355 mFocusedApplicationHandlesByDisplay GUARDED_BY(mLock);
Tiger Huang721e26f2018-07-24 22:26:19 +0800356
357 // Top focused display.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800358 int32_t mFocusedDisplayId GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800359
Prabir Pradhan99987712020-11-10 18:43:05 -0800360 // Whether the focused window on the focused display has requested Pointer Capture.
361 // The state of this variable should always be in sync with the state of Pointer Capture in the
362 // policy, which is updated through setPointerCaptureLocked(enabled).
363 bool mFocusedWindowRequestedPointerCapture GUARDED_BY(mLock);
364
365 // The window token that has Pointer Capture.
366 // This should be in sync with PointerCaptureChangedEvents dispatched to the input channel.
367 sp<IBinder> mWindowTokenWithPointerCapture GUARDED_BY(mLock);
368
369 // Disable Pointer Capture as a result of loss of window focus.
370 void disablePointerCaptureForcedLocked() REQUIRES(mLock);
371
372 // Set the Pointer Capture state in the Policy.
373 void setPointerCaptureLocked(bool enabled) REQUIRES(mLock);
374
Michael Wrightd02c5b62014-02-10 15:10:22 -0800375 // Dispatcher state at time of last ANR.
Siarhei Vishniakoub1a16272020-05-06 16:09:19 -0700376 std::string mLastAnrState GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800377
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +0000378 // The connection tokens of the channels that the user last interacted, for debugging
379 std::unordered_set<sp<IBinder>, IBinderHash> mInteractionConnectionTokens GUARDED_BY(mLock);
380 void updateInteractionTokensLocked(const EventEntry& entry,
381 const std::vector<InputTarget>& targets) REQUIRES(mLock);
382
Michael Wrightd02c5b62014-02-10 15:10:22 -0800383 // Dispatch inbound events.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700384 bool dispatchConfigurationChangedLocked(nsecs_t currentTime,
385 const ConfigurationChangedEntry& entry) REQUIRES(mLock);
386 bool dispatchDeviceResetLocked(nsecs_t currentTime, const DeviceResetEntry& entry)
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700387 REQUIRES(mLock);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700388 bool dispatchKeyLocked(nsecs_t currentTime, std::shared_ptr<KeyEntry> entry,
389 DropReason* dropReason, nsecs_t* nextWakeupTime) REQUIRES(mLock);
390 bool dispatchMotionLocked(nsecs_t currentTime, std::shared_ptr<MotionEntry> entry,
391 DropReason* dropReason, nsecs_t* nextWakeupTime) REQUIRES(mLock);
392 void dispatchFocusLocked(nsecs_t currentTime, std::shared_ptr<FocusEntry> entry)
393 REQUIRES(mLock);
Prabir Pradhan99987712020-11-10 18:43:05 -0800394 void dispatchPointerCaptureChangedLocked(
395 nsecs_t currentTime, const std::shared_ptr<PointerCaptureChangedEntry>& entry,
396 DropReason& dropReason) REQUIRES(mLock);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700397 void dispatchEventLocked(nsecs_t currentTime, std::shared_ptr<EventEntry> entry,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700398 const std::vector<InputTarget>& inputTargets) REQUIRES(mLock);
Chris Yef59a2f42020-10-16 12:55:26 -0700399 void dispatchSensorLocked(nsecs_t currentTime, std::shared_ptr<SensorEntry> entry,
400 DropReason* dropReason, nsecs_t* nextWakeupTime) REQUIRES(mLock);
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700401 void logOutboundKeyDetails(const char* prefix, const KeyEntry& entry);
402 void logOutboundMotionDetails(const char* prefix, const MotionEntry& entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800403
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700404 /**
405 * This field is set if there is no focused window, and we have an event that requires
406 * a focused window to be dispatched (for example, a KeyEvent).
407 * When this happens, we will wait until *mNoFocusedWindowTimeoutTime before
408 * dropping the event and raising an ANR for that application.
409 * This is useful if an application is slow to add a focused window.
410 */
411 std::optional<nsecs_t> mNoFocusedWindowTimeoutTime GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800412
Siarhei Vishniakoude1bc4a2020-05-26 22:39:43 -0700413 bool shouldPruneInboundQueueLocked(const MotionEntry& motionEntry) REQUIRES(mLock);
414
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700415 /**
416 * Time to stop waiting for the events to be processed while trying to dispatch a key.
417 * When this time expires, we just send the pending key event to the currently focused window,
418 * without waiting on other events to be processed first.
419 */
420 std::optional<nsecs_t> mKeyIsWaitingForEventsTimeout GUARDED_BY(mLock);
421 bool shouldWaitToSendKeyLocked(nsecs_t currentTime, const char* focusedWindowName)
422 REQUIRES(mLock);
423
424 /**
425 * The focused application at the time when no focused window was present.
426 * Used to raise an ANR when we have no focused window.
427 */
Chris Yea209fde2020-07-22 13:54:51 -0700428 std::shared_ptr<InputApplicationHandle> mAwaitedFocusedApplication GUARDED_BY(mLock);
Siarhei Vishniakouf56b2692020-09-08 19:43:33 -0500429 /**
430 * The displayId that the focused application is associated with.
431 */
432 int32_t mAwaitedApplicationDisplayId GUARDED_BY(mLock);
433 void processNoFocusedWindowAnrLocked() REQUIRES(mLock);
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700434
Vishnu Nair958da932020-08-21 17:12:37 -0700435 /**
436 * This map will store the pending focus requests that cannot be currently processed. This can
437 * happen if the window requested to be focused is not currently visible. Such a window might
438 * become visible later, and these requests would be processed at that time.
439 */
440 std::unordered_map<int32_t /* displayId */, FocusRequest> mPendingFocusRequests
441 GUARDED_BY(mLock);
442
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700443 // Optimization: AnrTracker is used to quickly find which connection is due for a timeout next.
444 // AnrTracker must be kept in-sync with all responsive connection.waitQueues.
445 // If a connection is not responsive, then the entries should not be added to the AnrTracker.
446 // Once a connection becomes unresponsive, its entries are removed from AnrTracker to
447 // prevent unneeded wakeups.
448 AnrTracker mAnrTracker GUARDED_BY(mLock);
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700449
Michael Wrightd02c5b62014-02-10 15:10:22 -0800450 // Contains the last window which received a hover event.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800451 sp<InputWindowHandle> mLastHoverWindowHandle GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800452
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700453 void cancelEventsForAnrLocked(const sp<Connection>& connection) REQUIRES(mLock);
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800454 nsecs_t getTimeSpentWaitingForApplicationLocked(nsecs_t currentTime) REQUIRES(mLock);
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700455 // If a focused application changes, we should stop counting down the "no focused window" time,
456 // because we will have no way of knowing when the previous application actually added a window.
457 // This also means that we will miss cases like pulling down notification shade when the
458 // focused application does not have a focused window (no ANR will be raised if notification
459 // shade is pulled down while we are counting down the timeout).
460 void resetNoFocusedWindowTimeoutLocked() REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800461
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700462 int32_t getTargetDisplayId(const EventEntry& entry);
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800463 android::os::InputEventInjectionResult findFocusedWindowTargetsLocked(
464 nsecs_t currentTime, const EventEntry& entry, std::vector<InputTarget>& inputTargets,
465 nsecs_t* nextWakeupTime) REQUIRES(mLock);
466 android::os::InputEventInjectionResult findTouchedWindowTargetsLocked(
467 nsecs_t currentTime, const MotionEntry& entry, std::vector<InputTarget>& inputTargets,
468 nsecs_t* nextWakeupTime, bool* outConflictingPointerActions) REQUIRES(mLock);
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700469 std::vector<TouchedMonitor> findTouchedGestureMonitorsLocked(
Siarhei Vishniakoue0fb6bd2020-04-13 11:40:37 -0700470 int32_t displayId, const std::vector<sp<InputWindowHandle>>& portalWindows) const
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700471 REQUIRES(mLock);
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700472 std::vector<TouchedMonitor> selectResponsiveMonitorsLocked(
473 const std::vector<TouchedMonitor>& gestureMonitors) const REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800474
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700475 void addWindowTargetLocked(const sp<InputWindowHandle>& windowHandle, int32_t targetFlags,
476 BitSet32 pointerIds, std::vector<InputTarget>& inputTargets)
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800477 REQUIRES(mLock);
Michael Wright3dd60e22019-03-27 22:06:44 +0000478 void addMonitoringTargetLocked(const Monitor& monitor, float xOffset, float yOffset,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700479 std::vector<InputTarget>& inputTargets) REQUIRES(mLock);
480 void addGlobalMonitoringTargetsLocked(std::vector<InputTarget>& inputTargets, int32_t displayId,
481 float xOffset = 0, float yOffset = 0) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800482
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700483 void pokeUserActivityLocked(const EventEntry& eventEntry) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800484 bool checkInjectionPermission(const sp<InputWindowHandle>& windowHandle,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700485 const InjectionState* injectionState);
Bernardo Rufinoea97d182020-08-19 14:43:14 +0100486
487 struct TouchOcclusionInfo {
488 bool hasBlockingOcclusion;
489 float obscuringOpacity;
490 std::string obscuringPackage;
491 int32_t obscuringUid;
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +0000492 std::vector<std::string> debugInfo;
Bernardo Rufinoea97d182020-08-19 14:43:14 +0100493 };
494
495 TouchOcclusionInfo computeTouchOcclusionInfoLocked(const sp<InputWindowHandle>& windowHandle,
496 int32_t x, int32_t y) const REQUIRES(mLock);
497 bool isTouchTrustedLocked(const TouchOcclusionInfo& occlusionInfo) const REQUIRES(mLock);
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700498 bool isWindowObscuredAtPointLocked(const sp<InputWindowHandle>& windowHandle, int32_t x,
499 int32_t y) const REQUIRES(mLock);
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800500 bool isWindowObscuredLocked(const sp<InputWindowHandle>& windowHandle) const REQUIRES(mLock);
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +0000501 std::string dumpWindowForTouchOcclusion(const InputWindowInfo* info, bool isTouchWindow) const;
Siarhei Vishniakou234129c2020-10-22 22:28:12 -0500502 std::string getApplicationWindowLabel(const InputApplicationHandle* applicationHandle,
503 const sp<InputWindowHandle>& windowHandle);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800504
Michael Wrightd02c5b62014-02-10 15:10:22 -0800505 // Manage the dispatch cycle for a single connection.
506 // These methods are deliberately not Interruptible because doing all of the work
507 // with the mutex held makes it easier to ensure that connection invariants are maintained.
508 // If needed, the methods post commands to run later once the critical bits are done.
509 void prepareDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700510 std::shared_ptr<EventEntry>, const InputTarget& inputTarget)
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700511 REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800512 void enqueueDispatchEntriesLocked(nsecs_t currentTime, const sp<Connection>& connection,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700513 std::shared_ptr<EventEntry>, const InputTarget& inputTarget)
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700514 REQUIRES(mLock);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700515 void enqueueDispatchEntryLocked(const sp<Connection>& connection, std::shared_ptr<EventEntry>,
Siarhei Vishniakou5d6b6612020-01-08 16:03:04 -0800516 const InputTarget& inputTarget, int32_t dispatchMode)
chaviw8c9cf542019-03-25 13:02:48 -0700517 REQUIRES(mLock);
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800518 void startDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection)
519 REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800520 void finishDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700521 uint32_t seq, bool handled) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800522 void abortBrokenDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700523 bool notify) REQUIRES(mLock);
Siarhei Vishniakou13bda6c2019-07-29 08:34:33 -0700524 void drainDispatchQueue(std::deque<DispatchEntry*>& queue);
Siarhei Vishniakou62683e82019-03-06 17:59:56 -0800525 void releaseDispatchEntry(DispatchEntry* dispatchEntry);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800526 static int handleReceiveCallback(int fd, int events, void* data);
chaviw8c9cf542019-03-25 13:02:48 -0700527 // The action sent should only be of type AMOTION_EVENT_*
chaviwfd6d3512019-03-25 13:23:49 -0700528 void dispatchPointerDownOutsideFocus(uint32_t source, int32_t action,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700529 const sp<IBinder>& newToken) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800530
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700531 void synthesizeCancelationEventsForAllConnectionsLocked(const CancelationOptions& options)
532 REQUIRES(mLock);
533 void synthesizeCancelationEventsForMonitorsLocked(const CancelationOptions& options)
534 REQUIRES(mLock);
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800535 void synthesizeCancelationEventsForMonitorsLocked(
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700536 const CancelationOptions& options,
Michael Wright3dd60e22019-03-27 22:06:44 +0000537 std::unordered_map<int32_t, std::vector<Monitor>>& monitorsByDisplay) REQUIRES(mLock);
Siarhei Vishniakouce5ab082020-07-09 17:03:21 -0500538 void synthesizeCancelationEventsForInputChannelLocked(
539 const std::shared_ptr<InputChannel>& channel, const CancelationOptions& options)
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700540 REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800541 void synthesizeCancelationEventsForConnectionLocked(const sp<Connection>& connection,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700542 const CancelationOptions& options)
543 REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800544
Svet Ganov5d3bc372020-01-26 23:11:07 -0800545 void synthesizePointerDownEventsForConnectionLocked(const sp<Connection>& connection)
546 REQUIRES(mLock);
547
Michael Wrightd02c5b62014-02-10 15:10:22 -0800548 // Splitting motion events across windows.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700549 std::unique_ptr<MotionEntry> splitMotionEvent(const MotionEntry& originalMotionEntry,
550 BitSet32 pointerIds);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800551
552 // Reset and drop everything the dispatcher is doing.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800553 void resetAndDropEverythingLocked(const char* reason) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800554
555 // Dump state.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800556 void dumpDispatchStateLocked(std::string& dump) REQUIRES(mLock);
Michael Wright3dd60e22019-03-27 22:06:44 +0000557 void dumpMonitors(std::string& dump, const std::vector<Monitor>& monitors);
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800558 void logDispatchStateLocked() REQUIRES(mLock);
Vishnu Nairad321cd2020-08-20 16:40:21 -0700559 std::string dumpFocusedWindowsLocked() REQUIRES(mLock);
Siarhei Vishniakouad991402020-10-28 11:40:09 -0500560 std::string dumpPendingFocusRequestsLocked() REQUIRES(mLock);
Prabir Pradhan99987712020-11-10 18:43:05 -0800561 std::string dumpPointerCaptureStateLocked() REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800562
563 // Registration.
Siarhei Vishniakouadefc3e2020-09-02 22:28:29 -0500564 void removeMonitorChannelLocked(const sp<IBinder>& connectionToken) REQUIRES(mLock);
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700565 void removeMonitorChannelLocked(
Siarhei Vishniakouadefc3e2020-09-02 22:28:29 -0500566 const sp<IBinder>& connectionToken,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700567 std::unordered_map<int32_t, std::vector<Monitor>>& monitorsByDisplay) REQUIRES(mLock);
Garfield Tan15601662020-09-22 15:32:38 -0700568 status_t removeInputChannelLocked(const sp<IBinder>& connectionToken, bool notify)
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800569 REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800570
571 // Interesting events that we might like to log or tell the framework about.
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700572 void onDispatchCycleFinishedLocked(nsecs_t currentTime, const sp<Connection>& connection,
573 uint32_t seq, bool handled) REQUIRES(mLock);
574 void onDispatchCycleBrokenLocked(nsecs_t currentTime, const sp<Connection>& connection)
575 REQUIRES(mLock);
Vishnu Nairad321cd2020-08-20 16:40:21 -0700576 void onFocusChangedLocked(const sp<IBinder>& oldFocus, const sp<IBinder>& newFocus,
577 int32_t displayId, std::string_view reason) REQUIRES(mLock);
578 void notifyFocusChangedLocked(const sp<IBinder>& oldFocus, const sp<IBinder>& newFocus)
579 REQUIRES(mLock);
Siarhei Vishniakoua72accd2020-09-22 21:43:09 -0500580 void onAnrLocked(const Connection& connection) REQUIRES(mLock);
Siarhei Vishniakou234129c2020-10-22 22:28:12 -0500581 void onAnrLocked(std::shared_ptr<InputApplicationHandle> application) REQUIRES(mLock);
Bernardo Rufino2e1f6512020-10-08 13:42:07 +0000582 void onUntrustedTouchLocked(const std::string& obscuringPackage) REQUIRES(mLock);
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700583 void updateLastAnrStateLocked(const sp<InputWindowHandle>& window, const std::string& reason)
584 REQUIRES(mLock);
Siarhei Vishniakou234129c2020-10-22 22:28:12 -0500585 void updateLastAnrStateLocked(const InputApplicationHandle& application,
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700586 const std::string& reason) REQUIRES(mLock);
587 void updateLastAnrStateLocked(const std::string& windowLabel, const std::string& reason)
588 REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800589
590 // Outbound policy interactions.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800591 void doNotifyConfigurationChangedLockedInterruptible(CommandEntry* commandEntry)
592 REQUIRES(mLock);
593 void doNotifyInputChannelBrokenLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock);
594 void doNotifyFocusChangedLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock);
Siarhei Vishniakou234129c2020-10-22 22:28:12 -0500595 void doNotifyNoFocusedWindowAnrLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock);
596 void doNotifyConnectionUnresponsiveLockedInterruptible(CommandEntry* commandEntry)
597 REQUIRES(mLock);
598 void doNotifyConnectionResponsiveLockedInterruptible(CommandEntry* commandEntry)
599 REQUIRES(mLock);
Chris Yef59a2f42020-10-16 12:55:26 -0700600 void doNotifySensorLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock);
Bernardo Rufino2e1f6512020-10-08 13:42:07 +0000601 void doNotifyUntrustedTouchLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock);
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800602 void doInterceptKeyBeforeDispatchingLockedInterruptible(CommandEntry* commandEntry)
603 REQUIRES(mLock);
604 void doDispatchCycleFinishedLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock);
Prabir Pradhan99987712020-11-10 18:43:05 -0800605 void doSetPointerCaptureLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800606 bool afterKeyEventLockedInterruptible(const sp<Connection>& connection,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700607 DispatchEntry* dispatchEntry, KeyEntry& keyEntry,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700608 bool handled) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800609 bool afterMotionEventLockedInterruptible(const sp<Connection>& connection,
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700610 DispatchEntry* dispatchEntry, MotionEntry& motionEntry,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700611 bool handled) REQUIRES(mLock);
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800612 void doPokeUserActivityLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock);
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700613 void doOnPointerDownOutsideFocusLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800614
615 // Statistics gathering.
Siarhei Vishniakoude4bf152019-08-16 11:12:52 -0500616 static constexpr std::chrono::duration TOUCH_STATS_REPORT_PERIOD = 5min;
617 LatencyStatistics mTouchStatistics{TOUCH_STATS_REPORT_PERIOD};
618
619 void reportTouchEventForStatistics(const MotionEntry& entry);
Siarhei Vishniakou7f0a4392020-03-24 20:49:09 -0700620 void reportDispatchStatistics(std::chrono::nanoseconds eventDuration,
621 const Connection& connection, bool handled);
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800622 void traceInboundQueueLengthLocked() REQUIRES(mLock);
623 void traceOutboundQueueLength(const sp<Connection>& connection);
624 void traceWaitQueueLength(const sp<Connection>& connection);
Prabir Pradhanf93562f2018-11-29 12:13:37 -0800625
Prabir Pradhan79a4f0c2019-01-09 11:24:01 -0800626 sp<InputReporterInterface> mReporter;
Siarhei Vishniakou2508b872020-12-03 16:33:53 -1000627 sp<com::android::internal::compat::IPlatformCompatNative> mCompatService;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800628};
629
Garfield Tane84e6f92019-08-29 17:28:41 -0700630} // namespace android::inputdispatcher
Michael Wrightd02c5b62014-02-10 15:10:22 -0800631
632#endif // _UI_INPUT_DISPATCHER_H