blob: f671ea71f403ea12374a7905bf58d37f64afab0b [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
Prabir Pradhan48108662022-09-09 21:22:04 +000017#pragma once
Michael Wrightd02c5b62014-02-10 15:10:22 -080018
Siarhei Vishniakoue4623042020-03-25 16:16:40 -070019#include "AnrTracker.h"
Garfield Tane84e6f92019-08-29 17:28:41 -070020#include "CancelationOptions.h"
arthurhung6d4bed92021-03-17 11:59:33 +080021#include "DragState.h"
Garfield Tane84e6f92019-08-29 17:28:41 -070022#include "Entry.h"
Vishnu Nairc519ff72021-01-21 08:23:08 -080023#include "FocusResolver.h"
Garfield Tane84e6f92019-08-29 17:28:41 -070024#include "InjectionState.h"
25#include "InputDispatcherConfiguration.h"
26#include "InputDispatcherInterface.h"
27#include "InputDispatcherPolicyInterface.h"
Garfield Tane84e6f92019-08-29 17:28:41 -070028#include "InputTarget.h"
Prabir Pradhan5a57cff2019-10-31 18:40:33 -070029#include "InputThread.h"
Siarhei Vishniakoua04181f2021-03-26 05:56:49 +000030#include "LatencyAggregator.h"
Siarhei Vishniakouf2652122021-03-05 21:39:46 +000031#include "LatencyTracker.h"
Garfield Tane84e6f92019-08-29 17:28:41 -070032#include "Monitor.h"
33#include "TouchState.h"
34#include "TouchedWindow.h"
Prabir Pradhanabcdf5c2023-12-15 07:30:22 +000035#include "trace/InputTracerInterface.h"
36#include "trace/InputTracingBackendInterface.h"
Garfield Tane84e6f92019-08-29 17:28:41 -070037
chaviw09c8d2d2020-08-24 15:48:26 -070038#include <attestation/HmacKeyManager.h>
chaviw98318de2021-05-19 16:45:23 -050039#include <gui/InputApplication.h>
Patrick Williamsd828f302023-04-28 17:52:08 -050040#include <gui/WindowInfosUpdate.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>
Yeabkal Wubshitb8aadfa2024-01-17 17:03:42 -080044#include <powermanager/PowerManager.h>
Garfield Tane84e6f92019-08-29 17:28:41 -070045#include <stddef.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>
Siarhei Vishniakou8a878352023-01-30 14:05:01 -080051#include <bitset>
Garfield Tan0fc2fa72019-08-29 17:22:15 -070052#include <condition_variable>
Garfield Tane84e6f92019-08-29 17:28:41 -070053#include <deque>
Garfield Tan0fc2fa72019-08-29 17:22:15 -070054#include <optional>
Robert Carr5c8a0262018-10-03 16:30:44 -070055#include <unordered_map>
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +000056#include <unordered_set>
Michael Wrightd02c5b62014-02-10 15:10:22 -080057
Garfield Tane84e6f92019-08-29 17:28:41 -070058#include <InputListener.h>
59#include <InputReporterInterface.h>
chaviw15fab6f2021-06-07 14:15:52 -050060#include <gui/WindowInfosListener.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080061
Garfield Tane84e6f92019-08-29 17:28:41 -070062namespace android::inputdispatcher {
Michael Wrightd02c5b62014-02-10 15:10:22 -080063
Garfield Tane84e6f92019-08-29 17:28:41 -070064class Connection;
Michael Wrightd02c5b62014-02-10 15:10:22 -080065
66/* Dispatches events to input targets. Some functions of the input dispatcher, such as
67 * identifying input targets, are controlled by a separate policy object.
68 *
69 * IMPORTANT INVARIANT:
70 * Because the policy can potentially block or cause re-entrance into the input dispatcher,
71 * the input dispatcher never calls into the policy while holding its internal locks.
72 * The implementation is also carefully designed to recover from scenarios such as an
73 * input channel becoming unregistered while identifying input targets or processing timeouts.
74 *
75 * Methods marked 'Locked' must be called with the lock acquired.
76 *
77 * Methods marked 'LockedInterruptible' must be called with the lock acquired but
78 * may during the course of their execution release the lock, call into the policy, and
79 * then reacquire the lock. The caller is responsible for recovering gracefully.
80 *
81 * A 'LockedInterruptible' method may called a 'Locked' method, but NOT vice-versa.
82 */
Siarhei Vishniakou18050092021-09-01 13:32:49 -070083class InputDispatcher : public android::InputDispatcherInterface {
Michael Wrightd02c5b62014-02-10 15:10:22 -080084public:
Antonio Kantekf16f2832021-09-28 04:39:20 +000085 static constexpr bool kDefaultInTouchMode = true;
86
Prabir Pradhana41d2442023-04-20 21:30:40 +000087 explicit InputDispatcher(InputDispatcherPolicyInterface& policy);
Prabir Pradhanabcdf5c2023-12-15 07:30:22 +000088 // Constructor used for testing.
89 explicit InputDispatcher(InputDispatcherPolicyInterface&,
90 std::unique_ptr<trace::InputTracingBackendInterface>);
Siarhei Vishniakou18050092021-09-01 13:32:49 -070091 ~InputDispatcher() override;
Michael Wrightd02c5b62014-02-10 15:10:22 -080092
Siarhei Vishniakou5e20f272023-06-08 17:24:44 -070093 void dump(std::string& dump) const override;
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +000094 void monitor() override;
Siarhei Vishniakoua66d65e2023-06-16 10:32:51 -070095 bool waitForIdle() const override;
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +000096 status_t start() override;
97 status_t stop() override;
Michael Wrightd02c5b62014-02-10 15:10:22 -080098
Asmita Poddardd9a6cd2023-09-26 15:35:12 +000099 void notifyInputDevicesChanged(const NotifyInputDevicesChangedArgs& args) override;
Prabir Pradhan678438e2023-04-13 19:32:51 +0000100 void notifyConfigurationChanged(const NotifyConfigurationChangedArgs& args) override;
101 void notifyKey(const NotifyKeyArgs& args) override;
102 void notifyMotion(const NotifyMotionArgs& args) override;
103 void notifySwitch(const NotifySwitchArgs& args) override;
104 void notifySensor(const NotifySensorArgs& args) override;
105 void notifyVibratorState(const NotifyVibratorStateArgs& args) override;
106 void notifyDeviceReset(const NotifyDeviceResetArgs& args) override;
107 void notifyPointerCaptureChanged(const NotifyPointerCaptureChangedArgs& args) override;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800108
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +0000109 android::os::InputEventInjectionResult injectInputEvent(
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +0000110 const InputEvent* event, std::optional<gui::Uid> targetUid,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800111 android::os::InputEventInjectionSync syncMode, std::chrono::milliseconds timeout,
112 uint32_t policyFlags) override;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800113
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +0000114 std::unique_ptr<VerifiedInputEvent> verifyInputEvent(const InputEvent& event) override;
Siarhei Vishniakou54d3e182020-01-15 17:38:38 -0800115
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +0000116 void setFocusedApplication(
Linnan Li13bf76a2024-05-05 19:18:02 +0800117 ui::LogicalDisplayId displayId,
Chris Yea209fde2020-07-22 13:54:51 -0700118 const std::shared_ptr<InputApplicationHandle>& inputApplicationHandle) override;
Linnan Li13bf76a2024-05-05 19:18:02 +0800119 void setFocusedDisplay(ui::LogicalDisplayId displayId) override;
Yeabkal Wubshitb8aadfa2024-01-17 17:03:42 -0800120 void setMinTimeBetweenUserActivityPokes(std::chrono::milliseconds interval) override;
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +0000121 void setInputDispatchMode(bool enabled, bool frozen) override;
122 void setInputFilterEnabled(bool enabled) override;
Prabir Pradhanaeebeb42023-06-13 19:53:03 +0000123 bool setInTouchMode(bool inTouchMode, gui::Pid pid, gui::Uid uid, bool hasPermission,
Linnan Li13bf76a2024-05-05 19:18:02 +0800124 ui::LogicalDisplayId displayId) override;
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +0000125 void setMaximumObscuringOpacityForTouch(float opacity) override;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800126
Prabir Pradhan367f3432024-02-13 23:05:58 +0000127 bool transferTouchGesture(const sp<IBinder>& fromToken, const sp<IBinder>& toToken,
128 bool isDragDrop = false) override;
Linnan Li13bf76a2024-05-05 19:18:02 +0800129 bool transferTouchOnDisplay(const sp<IBinder>& destChannelToken,
130 ui::LogicalDisplayId displayId) override;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800131
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +0000132 base::Result<std::unique_ptr<InputChannel>> createInputChannel(
Garfield Tan15601662020-09-22 15:32:38 -0700133 const std::string& name) override;
chaviw98318de2021-05-19 16:45:23 -0500134 void setFocusedWindow(const android::gui::FocusRequest&) override;
Linnan Li13bf76a2024-05-05 19:18:02 +0800135 base::Result<std::unique_ptr<InputChannel>> createInputMonitor(ui::LogicalDisplayId displayId,
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +0000136 const std::string& name,
Prabir Pradhanaeebeb42023-06-13 19:53:03 +0000137 gui::Pid pid) override;
Siarhei Vishniakoud0c6bc82021-03-13 03:14:52 +0000138 status_t removeInputChannel(const sp<IBinder>& connectionToken) override;
139 status_t pilferPointers(const sp<IBinder>& token) override;
140 void requestPointerCapture(const sp<IBinder>& windowToken, bool enabled) override;
141 bool flushSensor(int deviceId, InputDeviceSensorType sensorType) override;
Linnan Li13bf76a2024-05-05 19:18:02 +0800142 void setDisplayEligibilityForPointerCapture(ui::LogicalDisplayId displayId,
143 bool isEligible) override;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800144
chaviw09c8d2d2020-08-24 15:48:26 -0700145 std::array<uint8_t, 32> sign(const VerifiedInputEvent& event) const;
146
Linnan Li13bf76a2024-05-05 19:18:02 +0800147 void displayRemoved(ui::LogicalDisplayId displayId) override;
Vishnu Nair599f1412021-06-21 10:39:58 -0700148
Siarhei Vishniakou18050092021-09-01 13:32:49 -0700149 // Public because it's also used by tests to simulate the WindowInfosListener callback
Patrick Williamsd828f302023-04-28 17:52:08 -0500150 void onWindowInfosChanged(const gui::WindowInfosUpdate&);
chaviw15fab6f2021-06-07 14:15:52 -0500151
Arthur Hungdfd528e2021-12-08 13:23:04 +0000152 void cancelCurrentTouch() override;
153
Prabir Pradhan1376fcd2022-01-21 09:56:35 -0800154 // Public to allow tests to verify that a Monitor can get ANR.
155 void setMonitorDispatchingTimeoutForTest(std::chrono::nanoseconds timeout);
156
Siarhei Vishniakoufa2a0492023-11-14 13:13:18 -0800157 void setKeyRepeatConfiguration(std::chrono::nanoseconds timeout,
158 std::chrono::nanoseconds delay) override;
Nergi Rahardi730cf3c2023-04-13 12:41:17 +0900159
Linnan Li13bf76a2024-05-05 19:18:02 +0800160 bool isPointerInWindow(const sp<IBinder>& token, ui::LogicalDisplayId displayId,
161 DeviceId deviceId, int32_t pointerId) override;
Prabir Pradhan64f21d22023-11-28 21:19:42 +0000162
Prabir Pradhan04a66422024-03-15 22:45:27 +0000163 void setInputMethodConnectionIsActive(bool isActive) override;
164
Michael Wrightd02c5b62014-02-10 15:10:22 -0800165private:
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700166 enum class DropReason {
167 NOT_DROPPED,
168 POLICY,
Siarhei Vishniakou0fb1a0e2019-10-22 11:23:36 -0700169 DISABLED,
170 BLOCKED,
171 STALE,
Prabir Pradhan99987712020-11-10 18:43:05 -0800172 NO_POINTER_CAPTURE,
Michael Wrightd02c5b62014-02-10 15:10:22 -0800173 };
174
Prabir Pradhan5a57cff2019-10-31 18:40:33 -0700175 std::unique_ptr<InputThread> mThread;
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700176
Prabir Pradhana41d2442023-04-20 21:30:40 +0000177 InputDispatcherPolicyInterface& mPolicy;
Prabir Pradhan87112a72023-04-20 19:13:39 +0000178 android::InputDispatcherConfiguration mConfig GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800179
Siarhei Vishniakoua66d65e2023-06-16 10:32:51 -0700180 mutable std::mutex mLock;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800181
Siarhei Vishniakou443ad902019-03-06 17:25:41 -0800182 std::condition_variable mDispatcherIsAlive;
Siarhei Vishniakoua66d65e2023-06-16 10:32:51 -0700183 mutable std::condition_variable mDispatcherEnteredIdle;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800184
Prabir Pradhanabcdf5c2023-12-15 07:30:22 +0000185 // Input event tracer. The tracer will only exist on builds where input tracing is allowed.
186 std::unique_ptr<trace::InputTracerInterface> mTracer GUARDED_BY(mLock);
187
Michael Wrightd02c5b62014-02-10 15:10:22 -0800188 sp<Looper> mLooper;
189
Prabir Pradhan24047542023-11-02 17:14:59 +0000190 std::shared_ptr<const EventEntry> mPendingEvent GUARDED_BY(mLock);
191 std::deque<std::shared_ptr<const EventEntry>> mInboundQueue GUARDED_BY(mLock);
192 std::deque<std::shared_ptr<const EventEntry>> mRecentQueue GUARDED_BY(mLock);
Prabir Pradhancef936d2021-07-21 16:17:52 +0000193
194 // A command entry captures state and behavior for an action to be performed in the
195 // dispatch loop after the initial processing has taken place. It is essentially
196 // a kind of continuation used to postpone sensitive policy interactions to a point
197 // in the dispatch loop where it is safe to release the lock (generally after finishing
198 // the critical parts of the dispatch cycle).
199 //
200 // The special thing about commands is that they can voluntarily release and reacquire
201 // the dispatcher lock at will. Initially when the command starts running, the
202 // dispatcher lock is held. However, if the command needs to call into the policy to
203 // do some work, it can release the lock, do the work, then reacquire the lock again
204 // before returning.
205 //
206 // This mechanism is a bit clunky but it helps to preserve the invariant that the dispatch
207 // never calls into the policy while holding its lock.
208 //
209 // Commands are called with the lock held, but they can release and re-acquire the lock from
210 // within.
211 using Command = std::function<void()>;
212 std::deque<Command> mCommandQueue GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800213
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800214 DropReason mLastDropReason GUARDED_BY(mLock);
Michael Wright3a981722015-06-10 15:26:13 +0100215
Siarhei Vishniakou59e302b2023-06-05 08:04:53 -0700216 const IdGenerator mIdGenerator GUARDED_BY(mLock);
Garfield Tan1c7bc862020-01-28 13:24:04 -0800217
Patrick Williams9464b2c2023-05-23 11:22:04 -0500218 int64_t mWindowInfosVsyncId GUARDED_BY(mLock);
219
Yeabkal Wubshitb8aadfa2024-01-17 17:03:42 -0800220 std::chrono::milliseconds mMinTimeBetweenUserActivityPokes GUARDED_BY(mLock);
221
222 /** Stores the latest user-activity poke event times per user activity types. */
223 std::array<nsecs_t, USER_ACTIVITY_EVENT_LAST + 1> mLastUserActivityTimes GUARDED_BY(mLock);
224
Prabir Pradhan3608aad2019-10-02 17:08:26 -0700225 // With each iteration, InputDispatcher nominally processes one queued event,
226 // a timeout, or a response from an input consumer.
227 // This method should only be called on the input dispatcher's own thread.
228 void dispatchOnce();
229
Siarhei Vishniakou69505962023-12-28 12:07:04 -0800230 void dispatchOnceInnerLocked(nsecs_t& nextWakeupTime) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800231
232 // Enqueues an inbound event. Returns true if mLooper->wake() should be called.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700233 bool enqueueInboundEventLocked(std::unique_ptr<EventEntry> entry) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800234
235 // Cleans up input state when dropping an inbound event.
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700236 void dropInboundEventLocked(const EventEntry& entry, DropReason dropReason) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800237
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +0100238 // Enqueues a focus event.
Vishnu Nairad321cd2020-08-20 16:40:21 -0700239 void enqueueFocusEventLocked(const sp<IBinder>& windowToken, bool hasFocus,
Vishnu Nairc519ff72021-01-21 08:23:08 -0800240 const std::string& reason) REQUIRES(mLock);
arthurhungb89ccb02020-12-30 16:19:01 +0800241 // Enqueues a drag event.
chaviw98318de2021-05-19 16:45:23 -0500242 void enqueueDragEventLocked(const sp<android::gui::WindowInfoHandle>& windowToken,
Arthur Hung54745652022-04-20 07:17:41 +0000243 bool isExiting, const int32_t rawX, const int32_t rawY)
244 REQUIRES(mLock);
Siarhei Vishniakouf1035d42019-09-20 16:32:01 +0100245
Michael Wrightd02c5b62014-02-10 15:10:22 -0800246 // Adds an event to a queue of recent events for debugging purposes.
Prabir Pradhan24047542023-11-02 17:14:59 +0000247 void addRecentEventLocked(std::shared_ptr<const EventEntry> entry) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800248
Michael Wrightd02c5b62014-02-10 15:10:22 -0800249 // Blocked event latency optimization. Drops old events when the user intends
250 // to transfer focus to a new application.
Prabir Pradhan24047542023-11-02 17:14:59 +0000251 std::shared_ptr<const EventEntry> mNextUnblockedEvent GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800252
Siarhei Vishniakoue1ada272022-11-03 10:47:08 -0700253 sp<android::gui::WindowInfoHandle> findTouchedWindowAtLocked(
Linnan Li13bf76a2024-05-05 19:18:02 +0800254 ui::LogicalDisplayId displayId, float x, float y, bool isStylus = false,
Siarhei Vishniakoue1ada272022-11-03 10:47:08 -0700255 bool ignoreDragWindow = false) const REQUIRES(mLock);
256 std::vector<InputTarget> findOutsideTargetsLocked(
Linnan Li13bf76a2024-05-05 19:18:02 +0800257 ui::LogicalDisplayId displayId, const sp<android::gui::WindowInfoHandle>& touchedWindow,
Siarhei Vishniakou70f3d8c2023-09-19 15:36:52 -0700258 int32_t pointerId) const REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800259
Prabir Pradhand65552b2021-10-07 11:23:50 -0700260 std::vector<sp<android::gui::WindowInfoHandle>> findTouchedSpyWindowsAtLocked(
Linnan Li13bf76a2024-05-05 19:18:02 +0800261 ui::LogicalDisplayId displayId, float x, float y, bool isStylus) const REQUIRES(mLock);
Prabir Pradhan07e05b62021-11-19 03:57:24 -0800262
Linnan Li13bf76a2024-05-05 19:18:02 +0800263 sp<android::gui::WindowInfoHandle> findTouchedForegroundWindowLocked(
264 ui::LogicalDisplayId displayId) const REQUIRES(mLock);
Siarhei Vishniakou7ae7afd2022-03-31 15:26:13 -0700265
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -0700266 std::shared_ptr<Connection> getConnectionLocked(const sp<IBinder>& inputConnectionToken) const
Siarhei Vishniakouffaa2b12020-05-26 21:43:02 -0700267 REQUIRES(mLock);
268
Siarhei Vishniakouad991402020-10-28 11:40:09 -0500269 std::string getConnectionNameLocked(const sp<IBinder>& connectionToken) const REQUIRES(mLock);
270
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -0700271 void removeConnectionLocked(const std::shared_ptr<Connection>& connection) REQUIRES(mLock);
Siarhei Vishniakouffaa2b12020-05-26 21:43:02 -0700272
Vaibhav Devmurari6abcf8f2022-06-06 10:08:05 +0000273 status_t pilferPointersLocked(const sp<IBinder>& token) REQUIRES(mLock);
274
Prabir Pradhan6a9a8312021-04-23 11:59:31 -0700275 template <typename T>
276 struct StrongPointerHash {
277 std::size_t operator()(const sp<T>& b) const { return std::hash<T*>{}(b.get()); }
Robert Carr5c8a0262018-10-03 16:30:44 -0700278 };
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +0000279
280 // All registered connections mapped by input channel token.
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -0700281 std::unordered_map<sp<IBinder>, std::shared_ptr<Connection>, StrongPointerHash<IBinder>>
282 mConnectionsByToken GUARDED_BY(mLock);
Robert Carr5c8a0262018-10-03 16:30:44 -0700283
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000284 // Find a monitor pid by the provided token.
Prabir Pradhanaeebeb42023-06-13 19:53:03 +0000285 std::optional<gui::Pid> findMonitorPidByTokenLocked(const sp<IBinder>& token) REQUIRES(mLock);
Michael Wright3dd60e22019-03-27 22:06:44 +0000286
Arthur Hung2fbf37f2018-09-13 18:16:41 +0800287 // Input channels that will receive a copy of all input events sent to the provided display.
Linnan Li13bf76a2024-05-05 19:18:02 +0800288 std::unordered_map<ui::LogicalDisplayId, std::vector<Monitor>> mGlobalMonitorsByDisplay
289 GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800290
Edgar Arriaga3d61bc12020-04-16 18:46:48 -0700291 const HmacKeyManager mHmacKeyManager;
292 const std::array<uint8_t, 32> getSignature(const MotionEntry& motionEntry,
293 const DispatchEntry& dispatchEntry) const;
294 const std::array<uint8_t, 32> getSignature(const KeyEntry& keyEntry,
295 const DispatchEntry& dispatchEntry) const;
Gang Wange9087892020-01-07 12:17:14 -0500296
Michael Wrightd02c5b62014-02-10 15:10:22 -0800297 // Event injection and synchronization.
Siarhei Vishniakou443ad902019-03-06 17:25:41 -0800298 std::condition_variable mInjectionResultAvailable;
Prabir Pradhan24047542023-11-02 17:14:59 +0000299 void setInjectionResult(const EventEntry& entry,
Siarhei Vishniakouae6229e2019-12-30 16:23:19 -0800300 android::os::InputEventInjectionResult injectionResult);
Prabir Pradhandaa2f142021-12-10 09:30:08 +0000301 void transformMotionEntryForInjectionLocked(MotionEntry&,
302 const ui::Transform& injectedTransform) const
303 REQUIRES(mLock);
Daniel Normand604df12024-04-22 16:37:10 +0000304
Siarhei Vishniakou443ad902019-03-06 17:25:41 -0800305 std::condition_variable mInjectionSyncFinished;
Prabir Pradhan24047542023-11-02 17:14:59 +0000306 void incrementPendingForegroundDispatches(const EventEntry& entry);
307 void decrementPendingForegroundDispatches(const EventEntry& entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800308
309 // Key repeat tracking.
310 struct KeyRepeatState {
Prabir Pradhan24047542023-11-02 17:14:59 +0000311 std::shared_ptr<const KeyEntry> lastKeyEntry; // or null if no repeat
Michael Wrightd02c5b62014-02-10 15:10:22 -0800312 nsecs_t nextRepeatTime;
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800313 } mKeyRepeatState GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800314
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800315 void resetKeyRepeatLocked() REQUIRES(mLock);
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700316 std::shared_ptr<KeyEntry> synthesizeKeyRepeatLocked(nsecs_t currentTime) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800317
318 // Deferred command processing.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800319 bool haveCommandsLocked() const REQUIRES(mLock);
Prabir Pradhancef936d2021-07-21 16:17:52 +0000320 bool runCommandsLockedInterruptable() REQUIRES(mLock);
321 void postCommandLocked(Command&& command) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800322
Prabir Pradhan1376fcd2022-01-21 09:56:35 -0800323 // The dispatching timeout to use for Monitors.
324 std::chrono::nanoseconds mMonitorDispatchingTimeout GUARDED_BY(mLock);
325
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700326 nsecs_t processAnrsLocked() REQUIRES(mLock);
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -0700327 std::chrono::nanoseconds getDispatchingTimeoutLocked(
328 const std::shared_ptr<Connection>& connection) REQUIRES(mLock);
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700329
Michael Wrightd02c5b62014-02-10 15:10:22 -0800330 // Input filter processing.
Prabir Pradhan678438e2023-04-13 19:32:51 +0000331 bool shouldSendKeyToInputFilterLocked(const NotifyKeyArgs& args) REQUIRES(mLock);
332 bool shouldSendMotionToInputFilterLocked(const NotifyMotionArgs& args) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800333
334 // Inbound event processing.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800335 void drainInboundQueueLocked() REQUIRES(mLock);
336 void releasePendingEventLocked() REQUIRES(mLock);
Prabir Pradhan24047542023-11-02 17:14:59 +0000337 void releaseInboundEventLocked(std::shared_ptr<const EventEntry> entry) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800338
339 // Dispatch state.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800340 bool mDispatchEnabled GUARDED_BY(mLock);
341 bool mDispatchFrozen GUARDED_BY(mLock);
342 bool mInputFilterEnabled GUARDED_BY(mLock);
Bernardo Rufinoea97d182020-08-19 14:43:14 +0100343 float mMaximumObscuringOpacityForTouch GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800344
Antonio Kantek15beb512022-06-13 22:35:41 +0000345 // This map is not really needed, but it helps a lot with debugging (dumpsys input).
346 // In the java layer, touch mode states are spread across multiple DisplayContent objects,
347 // making harder to snapshot and retrieve them.
Linnan Li13bf76a2024-05-05 19:18:02 +0800348 std::map<ui::LogicalDisplayId /*displayId*/, bool /*inTouchMode*/> mTouchModePerDisplay
349 GUARDED_BY(mLock);
Antonio Kantek15beb512022-06-13 22:35:41 +0000350
Siarhei Vishniakou18050092021-09-01 13:32:49 -0700351 class DispatcherWindowListener : public gui::WindowInfosListener {
352 public:
353 explicit DispatcherWindowListener(InputDispatcher& dispatcher) : mDispatcher(dispatcher){};
Patrick Williamsd828f302023-04-28 17:52:08 -0500354 void onWindowInfosChanged(const gui::WindowInfosUpdate&) override;
Siarhei Vishniakou18050092021-09-01 13:32:49 -0700355
356 private:
357 InputDispatcher& mDispatcher;
358 };
359 sp<gui::WindowInfosListener> mWindowInfoListener;
360
Linnan Li13bf76a2024-05-05 19:18:02 +0800361 std::unordered_map<ui::LogicalDisplayId /*displayId*/,
362 std::vector<sp<android::gui::WindowInfoHandle>>>
chaviw98318de2021-05-19 16:45:23 -0500363 mWindowHandlesByDisplay GUARDED_BY(mLock);
Linnan Li13bf76a2024-05-05 19:18:02 +0800364 std::unordered_map<ui::LogicalDisplayId /*displayId*/, android::gui::DisplayInfo> mDisplayInfos
Prabir Pradhan48f8cb92021-08-26 14:05:36 -0700365 GUARDED_BY(mLock);
chaviw98318de2021-05-19 16:45:23 -0500366 void setInputWindowsLocked(
367 const std::vector<sp<android::gui::WindowInfoHandle>>& inputWindowHandles,
Linnan Li13bf76a2024-05-05 19:18:02 +0800368 ui::LogicalDisplayId displayId) REQUIRES(mLock);
Vishnu Nairad321cd2020-08-20 16:40:21 -0700369 // Get a reference to window handles by display, return an empty vector if not found.
chaviw98318de2021-05-19 16:45:23 -0500370 const std::vector<sp<android::gui::WindowInfoHandle>>& getWindowHandlesLocked(
Linnan Li13bf76a2024-05-05 19:18:02 +0800371 ui::LogicalDisplayId displayId) const REQUIRES(mLock);
372 ui::Transform getTransformLocked(ui::LogicalDisplayId displayId) const REQUIRES(mLock);
Vishnu Nairad321cd2020-08-20 16:40:21 -0700373
Prabir Pradhan16463382023-10-12 23:03:19 +0000374 sp<android::gui::WindowInfoHandle> getWindowHandleLocked(
Linnan Li13bf76a2024-05-05 19:18:02 +0800375 const sp<IBinder>& windowHandleToken,
376 std::optional<ui::LogicalDisplayId> displayId = {}) const REQUIRES(mLock);
chaviw98318de2021-05-19 16:45:23 -0500377 sp<android::gui::WindowInfoHandle> getWindowHandleLocked(
378 const sp<android::gui::WindowInfoHandle>& windowHandle) const REQUIRES(mLock);
Linnan Li13bf76a2024-05-05 19:18:02 +0800379 sp<android::gui::WindowInfoHandle> getFocusedWindowHandleLocked(
380 ui::LogicalDisplayId displayId) const REQUIRES(mLock);
Siarhei Vishniakoud4e3f3a2022-09-27 14:31:05 -0700381 bool canWindowReceiveMotionLocked(const sp<android::gui::WindowInfoHandle>& window,
382 const MotionEntry& motionEntry) const REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800383
Antonio Kantek15beb512022-06-13 22:35:41 +0000384 // Returns all the input targets (with their respective input channels) from the window handles
Antonio Kantek7242d8b2021-08-05 16:07:20 -0700385 // passed as argument.
386 std::vector<InputTarget> getInputTargetsFromWindowHandlesLocked(
387 const std::vector<sp<android::gui::WindowInfoHandle>>& windowHandles) const
388 REQUIRES(mLock);
389
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -0700390 /*
391 * Validate and update InputWindowHandles for a given display.
392 */
393 void updateWindowHandlesForDisplayLocked(
chaviw98318de2021-05-19 16:45:23 -0500394 const std::vector<sp<android::gui::WindowInfoHandle>>& inputWindowHandles,
Linnan Li13bf76a2024-05-05 19:18:02 +0800395 ui::LogicalDisplayId displayId) REQUIRES(mLock);
Siarhei Vishniakoub3ad35c2019-04-05 10:50:52 -0700396
Linnan Li13bf76a2024-05-05 19:18:02 +0800397 std::unordered_map<ui::LogicalDisplayId /*displayId*/, TouchState> mTouchStatesByDisplay
398 GUARDED_BY(mLock);
arthurhung6d4bed92021-03-17 11:59:33 +0800399 std::unique_ptr<DragState> mDragState GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800400
Vishnu Nair599f1412021-06-21 10:39:58 -0700401 void setFocusedApplicationLocked(
Linnan Li13bf76a2024-05-05 19:18:02 +0800402 ui::LogicalDisplayId displayId,
Vishnu Nair599f1412021-06-21 10:39:58 -0700403 const std::shared_ptr<InputApplicationHandle>& inputApplicationHandle) REQUIRES(mLock);
Tiger Huang721e26f2018-07-24 22:26:19 +0800404 // Focused applications.
Linnan Li13bf76a2024-05-05 19:18:02 +0800405 std::unordered_map<ui::LogicalDisplayId /*displayId*/, std::shared_ptr<InputApplicationHandle>>
Chris Yea209fde2020-07-22 13:54:51 -0700406 mFocusedApplicationHandlesByDisplay GUARDED_BY(mLock);
Tiger Huang721e26f2018-07-24 22:26:19 +0800407
408 // Top focused display.
Linnan Li13bf76a2024-05-05 19:18:02 +0800409 ui::LogicalDisplayId mFocusedDisplayId GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800410
Vishnu Nairc519ff72021-01-21 08:23:08 -0800411 // Keeps track of the focused window per display and determines focus changes.
412 FocusResolver mFocusResolver GUARDED_BY(mLock);
Prabir Pradhan5cc1a692021-08-06 14:01:18 +0000413
414 // The enabled state of this request is true iff the focused window on the focused display has
415 // requested Pointer Capture. This request also contains the sequence number associated with the
416 // current request. The state of this variable should always be in sync with the state of
417 // Pointer Capture in the policy, and is only updated through setPointerCaptureLocked(request).
418 PointerCaptureRequest mCurrentPointerCaptureRequest GUARDED_BY(mLock);
Prabir Pradhan99987712020-11-10 18:43:05 -0800419
420 // The window token that has Pointer Capture.
421 // This should be in sync with PointerCaptureChangedEvents dispatched to the input channel.
422 sp<IBinder> mWindowTokenWithPointerCapture GUARDED_BY(mLock);
423
Christine Franksb768bb42021-11-29 12:11:31 -0800424 // Displays that are ineligible for pointer capture.
425 // TODO(b/214621487): Remove or move to a display flag.
Linnan Li13bf76a2024-05-05 19:18:02 +0800426 std::vector<ui::LogicalDisplayId /*displayId*/> mIneligibleDisplaysForPointerCapture
427 GUARDED_BY(mLock);
Christine Franksb768bb42021-11-29 12:11:31 -0800428
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.
Hiroki Sato25040232024-02-22 17:21:22 +0900433 // The window is not nullptr for requests to enable, otherwise it is nullptr.
434 void setPointerCaptureLocked(const sp<IBinder>& window) REQUIRES(mLock);
Prabir Pradhan99987712020-11-10 18:43:05 -0800435
Michael Wrightd02c5b62014-02-10 15:10:22 -0800436 // Dispatcher state at time of last ANR.
Siarhei Vishniakoub1a16272020-05-06 16:09:19 -0700437 std::string mLastAnrState GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800438
Antonio Kantek48710e42022-03-24 14:19:30 -0700439 // The connection tokens of the channels that the user last interacted (used for debugging and
440 // when switching touch mode state).
Prabir Pradhan6a9a8312021-04-23 11:59:31 -0700441 std::unordered_set<sp<IBinder>, StrongPointerHash<IBinder>> mInteractionConnectionTokens
442 GUARDED_BY(mLock);
Prabir Pradhan8ede1d12023-05-08 19:37:44 +0000443 void processInteractionsLocked(const EventEntry& entry, const std::vector<InputTarget>& targets)
444 REQUIRES(mLock);
Siarhei Vishniakou887b7d92020-06-18 00:43:02 +0000445
Michael Wrightd02c5b62014-02-10 15:10:22 -0800446 // Dispatch inbound events.
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700447 bool dispatchConfigurationChangedLocked(nsecs_t currentTime,
448 const ConfigurationChangedEntry& entry) REQUIRES(mLock);
449 bool dispatchDeviceResetLocked(nsecs_t currentTime, const DeviceResetEntry& entry)
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700450 REQUIRES(mLock);
Prabir Pradhan24047542023-11-02 17:14:59 +0000451 bool dispatchKeyLocked(nsecs_t currentTime, std::shared_ptr<const KeyEntry> entry,
Siarhei Vishniakou69505962023-12-28 12:07:04 -0800452 DropReason* dropReason, nsecs_t& nextWakeupTime) REQUIRES(mLock);
Prabir Pradhan24047542023-11-02 17:14:59 +0000453 bool dispatchMotionLocked(nsecs_t currentTime, std::shared_ptr<const MotionEntry> entry,
Siarhei Vishniakou69505962023-12-28 12:07:04 -0800454 DropReason* dropReason, nsecs_t& nextWakeupTime) REQUIRES(mLock);
Prabir Pradhan24047542023-11-02 17:14:59 +0000455 void dispatchFocusLocked(nsecs_t currentTime, std::shared_ptr<const FocusEntry> entry)
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700456 REQUIRES(mLock);
Prabir Pradhan99987712020-11-10 18:43:05 -0800457 void dispatchPointerCaptureChangedLocked(
Prabir Pradhan24047542023-11-02 17:14:59 +0000458 nsecs_t currentTime, const std::shared_ptr<const PointerCaptureChangedEntry>& entry,
Prabir Pradhan99987712020-11-10 18:43:05 -0800459 DropReason& dropReason) REQUIRES(mLock);
Antonio Kantek7242d8b2021-08-05 16:07:20 -0700460 void dispatchTouchModeChangeLocked(nsecs_t currentTime,
Prabir Pradhan24047542023-11-02 17:14:59 +0000461 const std::shared_ptr<const TouchModeEntry>& entry)
Antonio Kantek7242d8b2021-08-05 16:07:20 -0700462 REQUIRES(mLock);
Prabir Pradhan24047542023-11-02 17:14:59 +0000463 void dispatchEventLocked(nsecs_t currentTime, std::shared_ptr<const EventEntry> entry,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700464 const std::vector<InputTarget>& inputTargets) REQUIRES(mLock);
Prabir Pradhan24047542023-11-02 17:14:59 +0000465 void dispatchSensorLocked(nsecs_t currentTime, const std::shared_ptr<const SensorEntry>& entry,
Siarhei Vishniakou69505962023-12-28 12:07:04 -0800466 DropReason* dropReason, nsecs_t& nextWakeupTime) REQUIRES(mLock);
Prabir Pradhan24047542023-11-02 17:14:59 +0000467 void dispatchDragLocked(nsecs_t currentTime, std::shared_ptr<const DragEntry> entry)
468 REQUIRES(mLock);
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700469 void logOutboundKeyDetails(const char* prefix, const KeyEntry& entry);
470 void logOutboundMotionDetails(const char* prefix, const MotionEntry& entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800471
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700472 /**
473 * This field is set if there is no focused window, and we have an event that requires
474 * a focused window to be dispatched (for example, a KeyEvent).
475 * When this happens, we will wait until *mNoFocusedWindowTimeoutTime before
476 * dropping the event and raising an ANR for that application.
477 * This is useful if an application is slow to add a focused window.
478 */
479 std::optional<nsecs_t> mNoFocusedWindowTimeoutTime GUARDED_BY(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800480
Siarhei Vishniakou289e9242022-02-15 14:50:16 -0800481 bool isStaleEvent(nsecs_t currentTime, const EventEntry& entry);
482
Siarhei Vishniakouef2b4502023-12-28 11:51:47 -0800483 bool shouldPruneInboundQueueLocked(const MotionEntry& motionEntry) const REQUIRES(mLock);
Siarhei Vishniakoude1bc4a2020-05-26 22:39:43 -0700484
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700485 /**
486 * Time to stop waiting for the events to be processed while trying to dispatch a key.
487 * When this time expires, we just send the pending key event to the currently focused window,
488 * without waiting on other events to be processed first.
489 */
490 std::optional<nsecs_t> mKeyIsWaitingForEventsTimeout GUARDED_BY(mLock);
491 bool shouldWaitToSendKeyLocked(nsecs_t currentTime, const char* focusedWindowName)
492 REQUIRES(mLock);
493
494 /**
495 * The focused application at the time when no focused window was present.
496 * Used to raise an ANR when we have no focused window.
497 */
Chris Yea209fde2020-07-22 13:54:51 -0700498 std::shared_ptr<InputApplicationHandle> mAwaitedFocusedApplication GUARDED_BY(mLock);
Siarhei Vishniakouf56b2692020-09-08 19:43:33 -0500499 /**
500 * The displayId that the focused application is associated with.
501 */
Linnan Li13bf76a2024-05-05 19:18:02 +0800502 ui::LogicalDisplayId mAwaitedApplicationDisplayId GUARDED_BY(mLock);
Siarhei Vishniakouf56b2692020-09-08 19:43:33 -0500503 void processNoFocusedWindowAnrLocked() REQUIRES(mLock);
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700504
Vishnu Nair958da932020-08-21 17:12:37 -0700505 /**
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000506 * Tell policy about a window or a monitor that just became unresponsive. Starts ANR.
507 */
508 void processConnectionUnresponsiveLocked(const Connection& connection, std::string reason)
509 REQUIRES(mLock);
510 /**
511 * Tell policy about a window or a monitor that just became responsive.
512 */
513 void processConnectionResponsiveLocked(const Connection& connection) REQUIRES(mLock);
514
Prabir Pradhanedd96402022-02-15 01:46:16 -0800515 void sendWindowUnresponsiveCommandLocked(const sp<IBinder>& connectionToken,
Prabir Pradhanaeebeb42023-06-13 19:53:03 +0000516 std::optional<gui::Pid> pid, std::string reason)
Siarhei Vishniakou3c63fa42020-12-15 02:59:54 +0000517 REQUIRES(mLock);
Prabir Pradhanedd96402022-02-15 01:46:16 -0800518 void sendWindowResponsiveCommandLocked(const sp<IBinder>& connectionToken,
Prabir Pradhanaeebeb42023-06-13 19:53:03 +0000519 std::optional<gui::Pid> pid) REQUIRES(mLock);
Vishnu Nair958da932020-08-21 17:12:37 -0700520
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700521 // Optimization: AnrTracker is used to quickly find which connection is due for a timeout next.
522 // AnrTracker must be kept in-sync with all responsive connection.waitQueues.
523 // If a connection is not responsive, then the entries should not be added to the AnrTracker.
524 // Once a connection becomes unresponsive, its entries are removed from AnrTracker to
525 // prevent unneeded wakeups.
526 AnrTracker mAnrTracker GUARDED_BY(mLock);
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700527
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -0700528 void cancelEventsForAnrLocked(const std::shared_ptr<Connection>& connection) REQUIRES(mLock);
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700529 // If a focused application changes, we should stop counting down the "no focused window" time,
530 // because we will have no way of knowing when the previous application actually added a window.
531 // This also means that we will miss cases like pulling down notification shade when the
532 // focused application does not have a focused window (no ANR will be raised if notification
533 // shade is pulled down while we are counting down the timeout).
534 void resetNoFocusedWindowTimeoutLocked() REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800535
Linnan Li13bf76a2024-05-05 19:18:02 +0800536 ui::LogicalDisplayId getTargetDisplayId(const EventEntry& entry);
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -0700537 sp<android::gui::WindowInfoHandle> findFocusedWindowTargetLocked(
Siarhei Vishniakou69505962023-12-28 12:07:04 -0800538 nsecs_t currentTime, const EventEntry& entry, nsecs_t& nextWakeupTime,
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -0700539 android::os::InputEventInjectionResult& outInjectionResult) REQUIRES(mLock);
Siarhei Vishniakou0026b4c2022-11-10 19:33:29 -0800540 std::vector<InputTarget> findTouchedWindowTargetsLocked(
Siarhei Vishniakou2899c552023-07-10 18:20:46 -0700541 nsecs_t currentTime, const MotionEntry& entry,
Siarhei Vishniakou6278ca22022-10-25 11:19:19 -0700542 android::os::InputEventInjectionResult& outInjectionResult) REQUIRES(mLock);
Prabir Pradhan0a99c922021-09-03 08:27:53 -0700543 std::vector<Monitor> selectResponsiveMonitorsLocked(
544 const std::vector<Monitor>& gestureMonitors) const REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800545
Siarhei Vishniakou6c377b32023-05-15 17:03:39 -0700546 std::optional<InputTarget> createInputTargetLocked(
547 const sp<android::gui::WindowInfoHandle>& windowHandle,
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +0000548 InputTarget::DispatchMode dispatchMode, ftl::Flags<InputTarget::Flags> targetFlags,
Siarhei Vishniakou6c377b32023-05-15 17:03:39 -0700549 std::optional<nsecs_t> firstDownTimeInTarget) const REQUIRES(mLock);
chaviw98318de2021-05-19 16:45:23 -0500550 void addWindowTargetLocked(const sp<android::gui::WindowInfoHandle>& windowHandle,
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +0000551 InputTarget::DispatchMode dispatchMode,
Siarhei Vishniakou8a878352023-01-30 14:05:01 -0800552 ftl::Flags<InputTarget::Flags> targetFlags,
Vaibhav Devmurari882bd9b2022-06-23 14:54:54 +0000553 std::optional<nsecs_t> firstDownTimeInTarget,
Siarhei Vishniakouf75cddb2022-10-25 10:42:16 -0700554 std::vector<InputTarget>& inputTargets) const REQUIRES(mLock);
Siarhei Vishniakou2899c552023-07-10 18:20:46 -0700555 void addPointerWindowTargetLocked(const sp<android::gui::WindowInfoHandle>& windowHandle,
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +0000556 InputTarget::DispatchMode dispatchMode,
Siarhei Vishniakou2899c552023-07-10 18:20:46 -0700557 ftl::Flags<InputTarget::Flags> targetFlags,
558 std::bitset<MAX_POINTER_ID + 1> pointerIds,
559 std::optional<nsecs_t> firstDownTimeInTarget,
560 std::vector<InputTarget>& inputTargets) const REQUIRES(mLock);
Linnan Li13bf76a2024-05-05 19:18:02 +0800561 void addGlobalMonitoringTargetsLocked(std::vector<InputTarget>& inputTargets,
562 ui::LogicalDisplayId displayId) REQUIRES(mLock);
Siarhei Vishniakoud2770042019-10-29 11:08:14 -0700563 void pokeUserActivityLocked(const EventEntry& eventEntry) REQUIRES(mLock);
arthurhungb89ccb02020-12-30 16:19:01 +0800564 // Enqueue a drag event if needed, and update the touch state.
565 // Uses findTouchedWindowTargetsLocked to make the decision
arthurhung6d4bed92021-03-17 11:59:33 +0800566 void addDragEventLocked(const MotionEntry& entry) REQUIRES(mLock);
Linnan Li13bf76a2024-05-05 19:18:02 +0800567 void finishDragAndDrop(ui::LogicalDisplayId displayId, float x, float y) REQUIRES(mLock);
Bernardo Rufinoea97d182020-08-19 14:43:14 +0100568
569 struct TouchOcclusionInfo {
570 bool hasBlockingOcclusion;
571 float obscuringOpacity;
572 std::string obscuringPackage;
Prabir Pradhan8a5c41d2023-06-08 19:13:46 +0000573 gui::Uid obscuringUid = gui::Uid::INVALID;
Bernardo Rufino4bae0ac2020-10-14 18:33:46 +0000574 std::vector<std::string> debugInfo;
Bernardo Rufinoea97d182020-08-19 14:43:14 +0100575 };
576
chaviw98318de2021-05-19 16:45:23 -0500577 TouchOcclusionInfo computeTouchOcclusionInfoLocked(
Linnan Li5e5645e2024-03-05 14:43:05 +0000578 const sp<android::gui::WindowInfoHandle>& windowHandle, float x, float y) const
chaviw98318de2021-05-19 16:45:23 -0500579 REQUIRES(mLock);
Bernardo Rufinoea97d182020-08-19 14:43:14 +0100580 bool isTouchTrustedLocked(const TouchOcclusionInfo& occlusionInfo) const REQUIRES(mLock);
chaviw98318de2021-05-19 16:45:23 -0500581 bool isWindowObscuredAtPointLocked(const sp<android::gui::WindowInfoHandle>& windowHandle,
Linnan Li5e5645e2024-03-05 14:43:05 +0000582 float x, float y) const REQUIRES(mLock);
chaviw98318de2021-05-19 16:45:23 -0500583 bool isWindowObscuredLocked(const sp<android::gui::WindowInfoHandle>& windowHandle) const
584 REQUIRES(mLock);
585 std::string dumpWindowForTouchOcclusion(const android::gui::WindowInfo* info,
586 bool isTouchWindow) const;
Siarhei Vishniakou234129c2020-10-22 22:28:12 -0500587 std::string getApplicationWindowLabel(const InputApplicationHandle* applicationHandle,
chaviw98318de2021-05-19 16:45:23 -0500588 const sp<android::gui::WindowInfoHandle>& windowHandle);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800589
Vishnu Nair062a8672021-09-03 16:07:44 -0700590 bool shouldDropInput(const EventEntry& entry,
591 const sp<android::gui::WindowInfoHandle>& windowHandle) const
592 REQUIRES(mLock);
593
Michael Wrightd02c5b62014-02-10 15:10:22 -0800594 // Manage the dispatch cycle for a single connection.
595 // These methods are deliberately not Interruptible because doing all of the work
596 // with the mutex held makes it easier to ensure that connection invariants are maintained.
597 // If needed, the methods post commands to run later once the critical bits are done.
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -0700598 void prepareDispatchCycleLocked(nsecs_t currentTime,
599 const std::shared_ptr<Connection>& connection,
Prabir Pradhan24047542023-11-02 17:14:59 +0000600 std::shared_ptr<const EventEntry>,
601 const InputTarget& inputTarget) REQUIRES(mLock);
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +0000602 void enqueueDispatchEntryAndStartDispatchCycleLocked(
603 nsecs_t currentTime, const std::shared_ptr<Connection>& connection,
604 std::shared_ptr<const EventEntry>, const InputTarget& inputTarget) REQUIRES(mLock);
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -0700605 void enqueueDispatchEntryLocked(const std::shared_ptr<Connection>& connection,
Prabir Pradhan24047542023-11-02 17:14:59 +0000606 std::shared_ptr<const EventEntry>,
Prabir Pradhan4b09c1f2023-11-17 03:16:25 +0000607 const InputTarget& inputTarget) REQUIRES(mLock);
Siarhei Vishniakoucce7e112022-10-25 13:31:17 -0700608 status_t publishMotionEvent(Connection& connection, DispatchEntry& dispatchEntry) const;
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -0700609 void startDispatchCycleLocked(nsecs_t currentTime,
610 const std::shared_ptr<Connection>& connection) REQUIRES(mLock);
611 void finishDispatchCycleLocked(nsecs_t currentTime,
612 const std::shared_ptr<Connection>& connection, uint32_t seq,
613 bool handled, nsecs_t consumeTime) REQUIRES(mLock);
614 void abortBrokenDispatchCycleLocked(nsecs_t currentTime,
615 const std::shared_ptr<Connection>& connection, bool notify)
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800616 REQUIRES(mLock);
Prabir Pradhan8c90d782023-09-15 21:16:44 +0000617 void drainDispatchQueue(std::deque<std::unique_ptr<DispatchEntry>>& queue);
618 void releaseDispatchEntry(std::unique_ptr<DispatchEntry> dispatchEntry);
Siarhei Vishniakouae02a1f2021-05-01 23:14:04 +0000619 int handleReceiveCallback(int events, sp<IBinder> connectionToken);
chaviw8c9cf542019-03-25 13:02:48 -0700620 // The action sent should only be of type AMOTION_EVENT_*
chaviwfd6d3512019-03-25 13:23:49 -0700621 void dispatchPointerDownOutsideFocus(uint32_t source, int32_t action,
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700622 const sp<IBinder>& newToken) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800623
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700624 void synthesizeCancelationEventsForAllConnectionsLocked(const CancelationOptions& options)
625 REQUIRES(mLock);
626 void synthesizeCancelationEventsForMonitorsLocked(const CancelationOptions& options)
627 REQUIRES(mLock);
Prabir Pradhanbb3f1c02024-01-04 20:17:14 +0000628 void synthesizeCancelationEventsForWindowLocked(const sp<gui::WindowInfoHandle>&,
629 const CancelationOptions&,
630 const std::shared_ptr<Connection>& = nullptr)
Garfield Tan0fc2fa72019-08-29 17:22:15 -0700631 REQUIRES(mLock);
Prabir Pradhanbb3f1c02024-01-04 20:17:14 +0000632 // This is a convenience function used to generate cancellation for a connection without having
633 // to check whether it's a monitor or a window. For non-monitors, the window handle must not be
634 // null. Always prefer the "-ForWindow" method above when explicitly dealing with windows.
635 void synthesizeCancelationEventsForConnectionLocked(
636 const std::shared_ptr<Connection>& connection, const CancelationOptions& options,
637 const sp<gui::WindowInfoHandle>& window) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800638
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -0700639 void synthesizePointerDownEventsForConnectionLocked(
640 const nsecs_t downTime, const std::shared_ptr<Connection>& connection,
Prabir Pradhand6b2b052024-02-21 23:25:15 +0000641 ftl::Flags<InputTarget::Flags> targetFlags,
642 const std::unique_ptr<trace::EventTrackerInterface>& traceTracker) REQUIRES(mLock);
Svet Ganov5d3bc372020-01-26 23:11:07 -0800643
Vaibhav Devmurari882bd9b2022-06-23 14:54:54 +0000644 // Splitting motion events across windows. When splitting motion event for a target,
645 // splitDownTime refers to the time of first 'down' event on that particular target
Siarhei Vishniakoua9a7ee82019-10-14 16:28:19 -0700646 std::unique_ptr<MotionEntry> splitMotionEvent(const MotionEntry& originalMotionEntry,
Siarhei Vishniakou8a878352023-01-30 14:05:01 -0800647 std::bitset<MAX_POINTER_ID + 1> pointerIds,
Siarhei Vishniakou59e302b2023-06-05 08:04:53 -0700648 nsecs_t splitDownTime) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800649
650 // Reset and drop everything the dispatcher is doing.
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800651 void resetAndDropEverythingLocked(const char* reason) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800652
653 // Dump state.
Siarhei Vishniakou4c9d6ff2023-04-18 11:23:20 -0700654 void dumpDispatchStateLocked(std::string& dump) const REQUIRES(mLock);
655 void dumpMonitors(std::string& dump, const std::vector<Monitor>& monitors) const;
656 void logDispatchStateLocked() const REQUIRES(mLock);
657 std::string dumpPointerCaptureStateLocked() const REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800658
659 // Registration.
Siarhei Vishniakouadefc3e2020-09-02 22:28:29 -0500660 void removeMonitorChannelLocked(const sp<IBinder>& connectionToken) REQUIRES(mLock);
Garfield Tan15601662020-09-22 15:32:38 -0700661 status_t removeInputChannelLocked(const sp<IBinder>& connectionToken, bool notify)
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800662 REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800663
664 // Interesting events that we might like to log or tell the framework about.
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -0700665 void doDispatchCycleFinishedCommand(nsecs_t finishTime,
666 const std::shared_ptr<Connection>& connection, uint32_t seq,
667 bool handled, nsecs_t consumeTime) REQUIRES(mLock);
Prabir Pradhancef936d2021-07-21 16:17:52 +0000668 void doInterceptKeyBeforeDispatchingCommand(const sp<IBinder>& focusedWindowToken,
Prabir Pradhan24047542023-11-02 17:14:59 +0000669 const KeyEntry& entry) REQUIRES(mLock);
Prabir Pradhan4b9b1a12024-02-02 00:16:17 +0000670 void onFocusChangedLocked(const FocusResolver::FocusChanges& changes,
Prabir Pradhand6b2b052024-02-21 23:25:15 +0000671 const std::unique_ptr<trace::EventTrackerInterface>& traceTracker,
Prabir Pradhan4b9b1a12024-02-02 00:16:17 +0000672 const sp<gui::WindowInfoHandle> removedFocusedWindowHandle = nullptr)
673 REQUIRES(mLock);
Prabir Pradhancef936d2021-07-21 16:17:52 +0000674 void sendFocusChangedCommandLocked(const sp<IBinder>& oldToken, const sp<IBinder>& newToken)
Vishnu Nairad321cd2020-08-20 16:40:21 -0700675 REQUIRES(mLock);
Prabir Pradhancef936d2021-07-21 16:17:52 +0000676 void sendDropWindowCommandLocked(const sp<IBinder>& token, float x, float y) REQUIRES(mLock);
Siarhei Vishniakou1069fa82023-04-19 12:14:39 -0700677 void onAnrLocked(const std::shared_ptr<Connection>& connection) REQUIRES(mLock);
Siarhei Vishniakou234129c2020-10-22 22:28:12 -0500678 void onAnrLocked(std::shared_ptr<InputApplicationHandle> application) REQUIRES(mLock);
chaviw98318de2021-05-19 16:45:23 -0500679 void updateLastAnrStateLocked(const sp<android::gui::WindowInfoHandle>& window,
680 const std::string& reason) REQUIRES(mLock);
Siarhei Vishniakou234129c2020-10-22 22:28:12 -0500681 void updateLastAnrStateLocked(const InputApplicationHandle& application,
Siarhei Vishniakoue4623042020-03-25 16:16:40 -0700682 const std::string& reason) REQUIRES(mLock);
683 void updateLastAnrStateLocked(const std::string& windowLabel, const std::string& reason)
684 REQUIRES(mLock);
Linnan Li13bf76a2024-05-05 19:18:02 +0800685 std::map<ui::LogicalDisplayId /*displayId*/, InputVerifier> mVerifiersByDisplay;
Prabir Pradhanb9dd1642023-11-02 18:05:36 +0000686 // Returns a fallback KeyEntry that should be sent to the connection, if required.
Prabir Pradhan24047542023-11-02 17:14:59 +0000687 std::unique_ptr<const KeyEntry> afterKeyEventLockedInterruptable(
Prabir Pradhanb9dd1642023-11-02 18:05:36 +0000688 const std::shared_ptr<Connection>& connection, DispatchEntry& dispatchEntry,
689 const KeyEntry& keyEntry, bool handled) REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800690
Arthur Hungabbb9d82021-09-01 14:52:30 +0000691 // Find touched state and touched window by token.
Linnan Li13bf76a2024-05-05 19:18:02 +0800692 std::tuple<TouchState*, TouchedWindow*, ui::LogicalDisplayId /*displayId*/>
Siarhei Vishniakou40b8fbd2022-11-04 10:50:26 -0700693 findTouchStateWindowAndDisplayLocked(const sp<IBinder>& token) REQUIRES(mLock);
Arthur Hungabbb9d82021-09-01 14:52:30 +0000694
Michael Wrightd02c5b62014-02-10 15:10:22 -0800695 // Statistics gathering.
Siarhei Vishniakoua04181f2021-03-26 05:56:49 +0000696 LatencyAggregator mLatencyAggregator GUARDED_BY(mLock);
Siarhei Vishniakouf2652122021-03-05 21:39:46 +0000697 LatencyTracker mLatencyTracker GUARDED_BY(mLock);
Siarhei Vishniakou61291d42019-02-11 18:13:20 -0800698 void traceInboundQueueLengthLocked() REQUIRES(mLock);
Siarhei Vishniakou060a7272021-02-03 19:40:10 +0000699 void traceOutboundQueueLength(const Connection& connection);
700 void traceWaitQueueLength(const Connection& connection);
Prabir Pradhanf93562f2018-11-29 12:13:37 -0800701
Antonio Kantek48710e42022-03-24 14:19:30 -0700702 // Check window ownership
Prabir Pradhanaeebeb42023-06-13 19:53:03 +0000703 bool focusedWindowIsOwnedByLocked(gui::Pid pid, gui::Uid uid) REQUIRES(mLock);
704 bool recentWindowsAreOwnedByLocked(gui::Pid pid, gui::Uid uid) REQUIRES(mLock);
Antonio Kantek48710e42022-03-24 14:19:30 -0700705
Prabir Pradhan79a4f0c2019-01-09 11:24:01 -0800706 sp<InputReporterInterface> mReporter;
Arthur Hungc539dbb2022-12-08 07:45:36 +0000707
708 void slipWallpaperTouch(ftl::Flags<InputTarget::Flags> targetFlags,
709 const sp<android::gui::WindowInfoHandle>& oldWindowHandle,
710 const sp<android::gui::WindowInfoHandle>& newWindowHandle,
Linnan Li72352222024-04-12 18:55:57 +0800711 TouchState& state, DeviceId deviceId,
Siarhei Vishniakou1ff00cc2023-12-13 16:12:13 -0800712 const PointerProperties& pointerProperties,
Siarhei Vishniakoubf880522023-05-01 11:03:22 -0700713 std::vector<InputTarget>& targets) const REQUIRES(mLock);
Arthur Hungc539dbb2022-12-08 07:45:36 +0000714 void transferWallpaperTouch(ftl::Flags<InputTarget::Flags> oldTargetFlags,
715 ftl::Flags<InputTarget::Flags> newTargetFlags,
716 const sp<android::gui::WindowInfoHandle> fromWindowHandle,
717 const sp<android::gui::WindowInfoHandle> toWindowHandle,
Linnan Li72352222024-04-12 18:55:57 +0800718 TouchState& state, DeviceId deviceId,
Prabir Pradhand6b2b052024-02-21 23:25:15 +0000719 const std::vector<PointerProperties>& pointers,
720 const std::unique_ptr<trace::EventTrackerInterface>& traceTracker)
721 REQUIRES(mLock);
Arthur Hungc539dbb2022-12-08 07:45:36 +0000722
723 sp<android::gui::WindowInfoHandle> findWallpaperWindowBelow(
724 const sp<android::gui::WindowInfoHandle>& windowHandle) const REQUIRES(mLock);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800725};
726
Garfield Tane84e6f92019-08-29 17:28:41 -0700727} // namespace android::inputdispatcher