blob: 73bcc258488a75060f45d3daff1b4a14c0ae3b5d [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
20#include <input/Input.h>
Robert Carr3720ed02018-08-08 16:08:27 -070021#include <input/InputApplication.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080022#include <input/InputTransport.h>
Robert Carr3720ed02018-08-08 16:08:27 -070023#include <input/InputWindow.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080024#include <utils/KeyedVector.h>
25#include <utils/Vector.h>
26#include <utils/threads.h>
27#include <utils/Timers.h>
28#include <utils/RefBase.h>
Michael Wrightd02c5b62014-02-10 15:10:22 -080029#include <utils/Looper.h>
30#include <utils/BitSet.h>
31#include <cutils/atomic.h>
Robert Carr5c8a0262018-10-03 16:30:44 -070032#include <unordered_map>
Michael Wrightd02c5b62014-02-10 15:10:22 -080033
34#include <stddef.h>
35#include <unistd.h>
36#include <limits.h>
Arthur Hungb92218b2018-08-14 12:00:21 +080037#include <unordered_map>
Michael Wrightd02c5b62014-02-10 15:10:22 -080038
Michael Wrightd02c5b62014-02-10 15:10:22 -080039#include "InputListener.h"
40
41
42namespace android {
43
44/*
45 * Constants used to report the outcome of input event injection.
46 */
47enum {
48 /* (INTERNAL USE ONLY) Specifies that injection is pending and its outcome is unknown. */
49 INPUT_EVENT_INJECTION_PENDING = -1,
50
51 /* Injection succeeded. */
52 INPUT_EVENT_INJECTION_SUCCEEDED = 0,
53
54 /* Injection failed because the injector did not have permission to inject
55 * into the application with input focus. */
56 INPUT_EVENT_INJECTION_PERMISSION_DENIED = 1,
57
58 /* Injection failed because there were no available input targets. */
59 INPUT_EVENT_INJECTION_FAILED = 2,
60
61 /* Injection failed due to a timeout. */
62 INPUT_EVENT_INJECTION_TIMED_OUT = 3
63};
64
65/*
66 * Constants used to determine the input event injection synchronization mode.
67 */
68enum {
69 /* Injection is asynchronous and is assumed always to be successful. */
70 INPUT_EVENT_INJECTION_SYNC_NONE = 0,
71
72 /* Waits for previous events to be dispatched so that the input dispatcher can determine
73 * whether input event injection willbe permitted based on the current input focus.
74 * Does not wait for the input event to finish processing. */
75 INPUT_EVENT_INJECTION_SYNC_WAIT_FOR_RESULT = 1,
76
77 /* Waits for the input event to be completely processed. */
78 INPUT_EVENT_INJECTION_SYNC_WAIT_FOR_FINISHED = 2,
79};
80
81
82/*
83 * An input target specifies how an input event is to be dispatched to a particular window
84 * including the window's input channel, control flags, a timeout, and an X / Y offset to
85 * be added to input event coordinates to compensate for the absolute position of the
86 * window area.
87 */
88struct InputTarget {
89 enum {
90 /* This flag indicates that the event is being delivered to a foreground application. */
91 FLAG_FOREGROUND = 1 << 0,
92
Michael Wrightcdcd8f22016-03-22 16:52:13 -070093 /* This flag indicates that the MotionEvent falls within the area of the target
Michael Wrightd02c5b62014-02-10 15:10:22 -080094 * obscured by another visible window above it. The motion event should be
95 * delivered with flag AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED. */
96 FLAG_WINDOW_IS_OBSCURED = 1 << 1,
97
98 /* This flag indicates that a motion event is being split across multiple windows. */
99 FLAG_SPLIT = 1 << 2,
100
101 /* This flag indicates that the pointer coordinates dispatched to the application
102 * will be zeroed out to avoid revealing information to an application. This is
103 * used in conjunction with FLAG_DISPATCH_AS_OUTSIDE to prevent apps not sharing
104 * the same UID from watching all touches. */
105 FLAG_ZERO_COORDS = 1 << 3,
106
107 /* This flag indicates that the event should be sent as is.
108 * Should always be set unless the event is to be transmuted. */
109 FLAG_DISPATCH_AS_IS = 1 << 8,
110
111 /* This flag indicates that a MotionEvent with AMOTION_EVENT_ACTION_DOWN falls outside
112 * of the area of this target and so should instead be delivered as an
113 * AMOTION_EVENT_ACTION_OUTSIDE to this target. */
114 FLAG_DISPATCH_AS_OUTSIDE = 1 << 9,
115
116 /* This flag indicates that a hover sequence is starting in the given window.
117 * The event is transmuted into ACTION_HOVER_ENTER. */
118 FLAG_DISPATCH_AS_HOVER_ENTER = 1 << 10,
119
120 /* This flag indicates that a hover event happened outside of a window which handled
121 * previous hover events, signifying the end of the current hover sequence for that
122 * window.
123 * The event is transmuted into ACTION_HOVER_ENTER. */
124 FLAG_DISPATCH_AS_HOVER_EXIT = 1 << 11,
125
126 /* This flag indicates that the event should be canceled.
127 * It is used to transmute ACTION_MOVE into ACTION_CANCEL when a touch slips
128 * outside of a window. */
129 FLAG_DISPATCH_AS_SLIPPERY_EXIT = 1 << 12,
130
131 /* This flag indicates that the event should be dispatched as an initial down.
132 * It is used to transmute ACTION_MOVE into ACTION_DOWN when a touch slips
133 * into a new window. */
134 FLAG_DISPATCH_AS_SLIPPERY_ENTER = 1 << 13,
135
136 /* Mask for all dispatch modes. */
137 FLAG_DISPATCH_MASK = FLAG_DISPATCH_AS_IS
138 | FLAG_DISPATCH_AS_OUTSIDE
139 | FLAG_DISPATCH_AS_HOVER_ENTER
140 | FLAG_DISPATCH_AS_HOVER_EXIT
141 | FLAG_DISPATCH_AS_SLIPPERY_EXIT
142 | FLAG_DISPATCH_AS_SLIPPERY_ENTER,
Michael Wrightcdcd8f22016-03-22 16:52:13 -0700143
144 /* This flag indicates that the target of a MotionEvent is partly or wholly
145 * obscured by another visible window above it. The motion event should be
146 * delivered with flag AMOTION_EVENT_FLAG_WINDOW_IS_PARTIALLY_OBSCURED. */
147 FLAG_WINDOW_IS_PARTIALLY_OBSCURED = 1 << 14,
148
Michael Wrightd02c5b62014-02-10 15:10:22 -0800149 };
150
151 // The input channel to be targeted.
152 sp<InputChannel> inputChannel;
153
154 // Flags for the input target.
155 int32_t flags;
156
157 // The x and y offset to add to a MotionEvent as it is delivered.
158 // (ignored for KeyEvents)
159 float xOffset, yOffset;
160
161 // Scaling factor to apply to MotionEvent as it is delivered.
162 // (ignored for KeyEvents)
Robert Carre07e1032018-11-26 12:55:53 -0800163 float globalScaleFactor;
164 float windowXScale = 1.0f;
165 float windowYScale = 1.0f;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800166
167 // The subset of pointer ids to include in motion events dispatched to this input target
168 // if FLAG_SPLIT is set.
169 BitSet32 pointerIds;
170};
171
172
173/*
174 * Input dispatcher configuration.
175 *
176 * Specifies various options that modify the behavior of the input dispatcher.
177 * The values provided here are merely defaults. The actual values will come from ViewConfiguration
178 * and are passed into the dispatcher during initialization.
179 */
180struct InputDispatcherConfiguration {
181 // The key repeat initial timeout.
182 nsecs_t keyRepeatTimeout;
183
184 // The key repeat inter-key delay.
185 nsecs_t keyRepeatDelay;
186
187 InputDispatcherConfiguration() :
188 keyRepeatTimeout(500 * 1000000LL),
189 keyRepeatDelay(50 * 1000000LL) { }
190};
191
192
193/*
194 * Input dispatcher policy interface.
195 *
196 * The input reader policy is used by the input reader to interact with the Window Manager
197 * and other system components.
198 *
199 * The actual implementation is partially supported by callbacks into the DVM
200 * via JNI. This interface is also mocked in the unit tests.
201 */
202class InputDispatcherPolicyInterface : public virtual RefBase {
203protected:
204 InputDispatcherPolicyInterface() { }
205 virtual ~InputDispatcherPolicyInterface() { }
206
207public:
208 /* Notifies the system that a configuration change has occurred. */
209 virtual void notifyConfigurationChanged(nsecs_t when) = 0;
210
211 /* Notifies the system that an application is not responding.
212 * Returns a new timeout to continue waiting, or 0 to abort dispatch. */
213 virtual nsecs_t notifyANR(const sp<InputApplicationHandle>& inputApplicationHandle,
Robert Carr803535b2018-08-02 16:38:15 -0700214 const sp<IBinder>& token,
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -0800215 const std::string& reason) = 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800216
217 /* Notifies the system that an input channel is unrecoverably broken. */
Robert Carr803535b2018-08-02 16:38:15 -0700218 virtual void notifyInputChannelBroken(const sp<IBinder>& token) = 0;
Robert Carrf759f162018-11-13 12:57:11 -0800219 virtual void notifyFocusChanged(const sp<IBinder>& token) = 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800220
221 /* Gets the input dispatcher configuration. */
222 virtual void getDispatcherConfiguration(InputDispatcherConfiguration* outConfig) = 0;
223
Michael Wrightd02c5b62014-02-10 15:10:22 -0800224 /* Filters an input event.
225 * Return true to dispatch the event unmodified, false to consume the event.
226 * A filter can also transform and inject events later by passing POLICY_FLAG_FILTERED
227 * to injectInputEvent.
228 */
229 virtual bool filterInputEvent(const InputEvent* inputEvent, uint32_t policyFlags) = 0;
230
231 /* Intercepts a key event immediately before queueing it.
232 * The policy can use this method as an opportunity to perform power management functions
233 * and early event preprocessing such as updating policy flags.
234 *
235 * This method is expected to set the POLICY_FLAG_PASS_TO_USER policy flag if the event
236 * should be dispatched to applications.
237 */
238 virtual void interceptKeyBeforeQueueing(const KeyEvent* keyEvent, uint32_t& policyFlags) = 0;
239
240 /* Intercepts a touch, trackball or other motion event before queueing it.
241 * The policy can use this method as an opportunity to perform power management functions
242 * and early event preprocessing such as updating policy flags.
243 *
244 * This method is expected to set the POLICY_FLAG_PASS_TO_USER policy flag if the event
245 * should be dispatched to applications.
246 */
247 virtual void interceptMotionBeforeQueueing(nsecs_t when, uint32_t& policyFlags) = 0;
248
249 /* Allows the policy a chance to intercept a key before dispatching. */
Robert Carr803535b2018-08-02 16:38:15 -0700250 virtual nsecs_t interceptKeyBeforeDispatching(const sp<IBinder>& token,
Michael Wrightd02c5b62014-02-10 15:10:22 -0800251 const KeyEvent* keyEvent, uint32_t policyFlags) = 0;
252
253 /* Allows the policy a chance to perform default processing for an unhandled key.
254 * Returns an alternate keycode to redispatch as a fallback, or 0 to give up. */
Robert Carr803535b2018-08-02 16:38:15 -0700255 virtual bool dispatchUnhandledKey(const sp<IBinder>& token,
Michael Wrightd02c5b62014-02-10 15:10:22 -0800256 const KeyEvent* keyEvent, uint32_t policyFlags, KeyEvent* outFallbackKeyEvent) = 0;
257
258 /* Notifies the policy about switch events.
259 */
260 virtual void notifySwitch(nsecs_t when,
261 uint32_t switchValues, uint32_t switchMask, uint32_t policyFlags) = 0;
262
263 /* Poke user activity for an event dispatched to a window. */
264 virtual void pokeUserActivity(nsecs_t eventTime, int32_t eventType) = 0;
265
266 /* Checks whether a given application pid/uid has permission to inject input events
267 * into other applications.
268 *
269 * This method is special in that its implementation promises to be non-reentrant and
270 * is safe to call while holding other locks. (Most other methods make no such guarantees!)
271 */
272 virtual bool checkInjectEventsPermissionNonReentrant(
273 int32_t injectorPid, int32_t injectorUid) = 0;
274};
275
276
277/* Notifies the system about input events generated by the input reader.
278 * The dispatcher is expected to be mostly asynchronous. */
279class InputDispatcherInterface : public virtual RefBase, public InputListenerInterface {
280protected:
281 InputDispatcherInterface() { }
282 virtual ~InputDispatcherInterface() { }
283
284public:
285 /* Dumps the state of the input dispatcher.
286 *
287 * This method may be called on any thread (usually by the input manager). */
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -0800288 virtual void dump(std::string& dump) = 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800289
290 /* Called by the heatbeat to ensures that the dispatcher has not deadlocked. */
291 virtual void monitor() = 0;
292
293 /* Runs a single iteration of the dispatch loop.
294 * Nominally processes one queued event, a timeout, or a response from an input consumer.
295 *
296 * This method should only be called on the input dispatcher thread.
297 */
298 virtual void dispatchOnce() = 0;
299
300 /* Injects an input event and optionally waits for sync.
301 * The synchronization mode determines whether the method blocks while waiting for
302 * input injection to proceed.
303 * Returns one of the INPUT_EVENT_INJECTION_XXX constants.
304 *
305 * This method may be called on any thread (usually by the input manager).
306 */
Siarhei Vishniakou777a10b2018-01-31 16:45:06 -0800307 virtual int32_t injectInputEvent(const InputEvent* event,
Michael Wrightd02c5b62014-02-10 15:10:22 -0800308 int32_t injectorPid, int32_t injectorUid, int32_t syncMode, int32_t timeoutMillis,
309 uint32_t policyFlags) = 0;
310
311 /* Sets the list of input windows.
312 *
313 * This method may be called on any thread (usually by the input manager).
314 */
Arthur Hungb92218b2018-08-14 12:00:21 +0800315 virtual void setInputWindows(const Vector<sp<InputWindowHandle> >& inputWindowHandles,
316 int32_t displayId) = 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800317
Tiger Huang721e26f2018-07-24 22:26:19 +0800318 /* Sets the focused application on the given display.
Michael Wrightd02c5b62014-02-10 15:10:22 -0800319 *
320 * This method may be called on any thread (usually by the input manager).
321 */
322 virtual void setFocusedApplication(
Tiger Huang721e26f2018-07-24 22:26:19 +0800323 int32_t displayId, const sp<InputApplicationHandle>& inputApplicationHandle) = 0;
324
325 /* Sets the focused display.
326 *
327 * This method may be called on any thread (usually by the input manager).
328 */
329 virtual void setFocusedDisplay(int32_t displayId) = 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800330
331 /* Sets the input dispatching mode.
332 *
333 * This method may be called on any thread (usually by the input manager).
334 */
335 virtual void setInputDispatchMode(bool enabled, bool frozen) = 0;
336
337 /* Sets whether input event filtering is enabled.
338 * When enabled, incoming input events are sent to the policy's filterInputEvent
339 * method instead of being dispatched. The filter is expected to use
340 * injectInputEvent to inject the events it would like to have dispatched.
341 * It should include POLICY_FLAG_FILTERED in the policy flags during injection.
342 */
343 virtual void setInputFilterEnabled(bool enabled) = 0;
344
345 /* Transfers touch focus from the window associated with one channel to the
346 * window associated with the other channel.
347 *
348 * Returns true on success. False if the window did not actually have touch focus.
349 */
350 virtual bool transferTouchFocus(const sp<InputChannel>& fromChannel,
351 const sp<InputChannel>& toChannel) = 0;
352
Arthur Hung2fbf37f2018-09-13 18:16:41 +0800353 /* Registers input channels that may be used as targets for input events.
354 * If inputWindowHandle is null, and displayId is not ADISPLAY_ID_NONE,
355 * the channel will receive a copy of all input events form the specific displayId.
Michael Wrightd02c5b62014-02-10 15:10:22 -0800356 *
Arthur Hung2fbf37f2018-09-13 18:16:41 +0800357 * This method may be called on any thread (usually by the input manager).
Michael Wrightd02c5b62014-02-10 15:10:22 -0800358 */
Robert Carr803535b2018-08-02 16:38:15 -0700359 virtual status_t registerInputChannel(
360 const sp<InputChannel>& inputChannel, int32_t displayId) = 0;
Arthur Hung2fbf37f2018-09-13 18:16:41 +0800361
362 /* Unregister input channels that will no longer receive input events.
363 *
364 * This method may be called on any thread (usually by the input manager).
365 */
Michael Wrightd02c5b62014-02-10 15:10:22 -0800366 virtual status_t unregisterInputChannel(const sp<InputChannel>& inputChannel) = 0;
367};
368
369/* Dispatches events to input targets. Some functions of the input dispatcher, such as
370 * identifying input targets, are controlled by a separate policy object.
371 *
372 * IMPORTANT INVARIANT:
373 * Because the policy can potentially block or cause re-entrance into the input dispatcher,
374 * the input dispatcher never calls into the policy while holding its internal locks.
375 * The implementation is also carefully designed to recover from scenarios such as an
376 * input channel becoming unregistered while identifying input targets or processing timeouts.
377 *
378 * Methods marked 'Locked' must be called with the lock acquired.
379 *
380 * Methods marked 'LockedInterruptible' must be called with the lock acquired but
381 * may during the course of their execution release the lock, call into the policy, and
382 * then reacquire the lock. The caller is responsible for recovering gracefully.
383 *
384 * A 'LockedInterruptible' method may called a 'Locked' method, but NOT vice-versa.
385 */
386class InputDispatcher : public InputDispatcherInterface {
387protected:
388 virtual ~InputDispatcher();
389
390public:
391 explicit InputDispatcher(const sp<InputDispatcherPolicyInterface>& policy);
392
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -0800393 virtual void dump(std::string& dump);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800394 virtual void monitor();
395
396 virtual void dispatchOnce();
397
398 virtual void notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args);
399 virtual void notifyKey(const NotifyKeyArgs* args);
400 virtual void notifyMotion(const NotifyMotionArgs* args);
401 virtual void notifySwitch(const NotifySwitchArgs* args);
402 virtual void notifyDeviceReset(const NotifyDeviceResetArgs* args);
403
Siarhei Vishniakou777a10b2018-01-31 16:45:06 -0800404 virtual int32_t injectInputEvent(const InputEvent* event,
Michael Wrightd02c5b62014-02-10 15:10:22 -0800405 int32_t injectorPid, int32_t injectorUid, int32_t syncMode, int32_t timeoutMillis,
406 uint32_t policyFlags);
407
Arthur Hungb92218b2018-08-14 12:00:21 +0800408 virtual void setInputWindows(const Vector<sp<InputWindowHandle> >& inputWindowHandles,
409 int32_t displayId);
Tiger Huang721e26f2018-07-24 22:26:19 +0800410 virtual void setFocusedApplication(int32_t displayId,
411 const sp<InputApplicationHandle>& inputApplicationHandle);
412 virtual void setFocusedDisplay(int32_t displayId);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800413 virtual void setInputDispatchMode(bool enabled, bool frozen);
414 virtual void setInputFilterEnabled(bool enabled);
415
416 virtual bool transferTouchFocus(const sp<InputChannel>& fromChannel,
417 const sp<InputChannel>& toChannel);
418
419 virtual status_t registerInputChannel(const sp<InputChannel>& inputChannel,
Robert Carr803535b2018-08-02 16:38:15 -0700420 int32_t displayId);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800421 virtual status_t unregisterInputChannel(const sp<InputChannel>& inputChannel);
422
423private:
424 template <typename T>
425 struct Link {
426 T* next;
427 T* prev;
428
429 protected:
Yi Kong9b14ac62018-07-17 13:48:38 -0700430 inline Link() : next(nullptr), prev(nullptr) { }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800431 };
432
433 struct InjectionState {
434 mutable int32_t refCount;
435
436 int32_t injectorPid;
437 int32_t injectorUid;
438 int32_t injectionResult; // initially INPUT_EVENT_INJECTION_PENDING
439 bool injectionIsAsync; // set to true if injection is not waiting for the result
440 int32_t pendingForegroundDispatches; // the number of foreground dispatches in progress
441
442 InjectionState(int32_t injectorPid, int32_t injectorUid);
443 void release();
444
445 private:
446 ~InjectionState();
447 };
448
449 struct EventEntry : Link<EventEntry> {
450 enum {
451 TYPE_CONFIGURATION_CHANGED,
452 TYPE_DEVICE_RESET,
453 TYPE_KEY,
454 TYPE_MOTION
455 };
456
457 mutable int32_t refCount;
458 int32_t type;
459 nsecs_t eventTime;
460 uint32_t policyFlags;
461 InjectionState* injectionState;
462
463 bool dispatchInProgress; // initially false, set to true while dispatching
464
Yi Kong9b14ac62018-07-17 13:48:38 -0700465 inline bool isInjected() const { return injectionState != nullptr; }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800466
467 void release();
468
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -0800469 virtual void appendDescription(std::string& msg) const = 0;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800470
471 protected:
472 EventEntry(int32_t type, nsecs_t eventTime, uint32_t policyFlags);
473 virtual ~EventEntry();
474 void releaseInjectionState();
475 };
476
477 struct ConfigurationChangedEntry : EventEntry {
Chih-Hung Hsieh6d2ede12016-09-01 11:28:23 -0700478 explicit ConfigurationChangedEntry(nsecs_t eventTime);
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -0800479 virtual void appendDescription(std::string& msg) const;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800480
481 protected:
482 virtual ~ConfigurationChangedEntry();
483 };
484
485 struct DeviceResetEntry : EventEntry {
486 int32_t deviceId;
487
488 DeviceResetEntry(nsecs_t eventTime, int32_t deviceId);
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -0800489 virtual void appendDescription(std::string& msg) const;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800490
491 protected:
492 virtual ~DeviceResetEntry();
493 };
494
495 struct KeyEntry : EventEntry {
496 int32_t deviceId;
497 uint32_t source;
Siarhei Vishniakoua62a8dd2018-06-08 21:17:33 +0100498 int32_t displayId;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800499 int32_t action;
500 int32_t flags;
501 int32_t keyCode;
502 int32_t scanCode;
503 int32_t metaState;
504 int32_t repeatCount;
505 nsecs_t downTime;
506
507 bool syntheticRepeat; // set to true for synthetic key repeats
508
509 enum InterceptKeyResult {
510 INTERCEPT_KEY_RESULT_UNKNOWN,
511 INTERCEPT_KEY_RESULT_SKIP,
512 INTERCEPT_KEY_RESULT_CONTINUE,
513 INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER,
514 };
515 InterceptKeyResult interceptKeyResult; // set based on the interception result
516 nsecs_t interceptKeyWakeupTime; // used with INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER
517
518 KeyEntry(nsecs_t eventTime,
Siarhei Vishniakoua62a8dd2018-06-08 21:17:33 +0100519 int32_t deviceId, uint32_t source, int32_t displayId, uint32_t policyFlags,
520 int32_t action, int32_t flags, int32_t keyCode, int32_t scanCode, int32_t metaState,
Michael Wrightd02c5b62014-02-10 15:10:22 -0800521 int32_t repeatCount, nsecs_t downTime);
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -0800522 virtual void appendDescription(std::string& msg) const;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800523 void recycle();
524
525 protected:
526 virtual ~KeyEntry();
527 };
528
529 struct MotionEntry : EventEntry {
530 nsecs_t eventTime;
531 int32_t deviceId;
532 uint32_t source;
Siarhei Vishniakou777a10b2018-01-31 16:45:06 -0800533 int32_t displayId;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800534 int32_t action;
Michael Wright7b159c92015-05-14 14:48:03 +0100535 int32_t actionButton;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800536 int32_t flags;
537 int32_t metaState;
538 int32_t buttonState;
539 int32_t edgeFlags;
540 float xPrecision;
541 float yPrecision;
542 nsecs_t downTime;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800543 uint32_t pointerCount;
544 PointerProperties pointerProperties[MAX_POINTERS];
545 PointerCoords pointerCoords[MAX_POINTERS];
546
547 MotionEntry(nsecs_t eventTime,
Siarhei Vishniakou777a10b2018-01-31 16:45:06 -0800548 int32_t deviceId, uint32_t source, int32_t displayId, uint32_t policyFlags,
Michael Wright7b159c92015-05-14 14:48:03 +0100549 int32_t action, int32_t actionButton, int32_t flags,
Michael Wrightd02c5b62014-02-10 15:10:22 -0800550 int32_t metaState, int32_t buttonState, int32_t edgeFlags,
Siarhei Vishniakou777a10b2018-01-31 16:45:06 -0800551 float xPrecision, float yPrecision, nsecs_t downTime, uint32_t pointerCount,
Jeff Brownf086ddb2014-02-11 14:28:48 -0800552 const PointerProperties* pointerProperties, const PointerCoords* pointerCoords,
553 float xOffset, float yOffset);
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -0800554 virtual void appendDescription(std::string& msg) const;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800555
556 protected:
557 virtual ~MotionEntry();
558 };
559
560 // Tracks the progress of dispatching a particular event to a particular connection.
561 struct DispatchEntry : Link<DispatchEntry> {
562 const uint32_t seq; // unique sequence number, never 0
563
564 EventEntry* eventEntry; // the event to dispatch
565 int32_t targetFlags;
566 float xOffset;
567 float yOffset;
Robert Carre07e1032018-11-26 12:55:53 -0800568 float globalScaleFactor;
569 float windowXScale = 1.0f;
570 float windowYScale = 1.0f;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800571 nsecs_t deliveryTime; // time when the event was actually delivered
572
573 // Set to the resolved action and flags when the event is enqueued.
574 int32_t resolvedAction;
575 int32_t resolvedFlags;
576
577 DispatchEntry(EventEntry* eventEntry,
Robert Carre07e1032018-11-26 12:55:53 -0800578 int32_t targetFlags, float xOffset, float yOffset,
579 float globalScaleFactor, float windowXScale, float windowYScale);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800580 ~DispatchEntry();
581
582 inline bool hasForegroundTarget() const {
583 return targetFlags & InputTarget::FLAG_FOREGROUND;
584 }
585
586 inline bool isSplit() const {
587 return targetFlags & InputTarget::FLAG_SPLIT;
588 }
589
590 private:
591 static volatile int32_t sNextSeqAtomic;
592
593 static uint32_t nextSeq();
594 };
595
596 // A command entry captures state and behavior for an action to be performed in the
597 // dispatch loop after the initial processing has taken place. It is essentially
598 // a kind of continuation used to postpone sensitive policy interactions to a point
599 // in the dispatch loop where it is safe to release the lock (generally after finishing
600 // the critical parts of the dispatch cycle).
601 //
602 // The special thing about commands is that they can voluntarily release and reacquire
603 // the dispatcher lock at will. Initially when the command starts running, the
604 // dispatcher lock is held. However, if the command needs to call into the policy to
605 // do some work, it can release the lock, do the work, then reacquire the lock again
606 // before returning.
607 //
608 // This mechanism is a bit clunky but it helps to preserve the invariant that the dispatch
609 // never calls into the policy while holding its lock.
610 //
611 // Commands are implicitly 'LockedInterruptible'.
612 struct CommandEntry;
613 typedef void (InputDispatcher::*Command)(CommandEntry* commandEntry);
614
615 class Connection;
616 struct CommandEntry : Link<CommandEntry> {
Chih-Hung Hsieh6d2ede12016-09-01 11:28:23 -0700617 explicit CommandEntry(Command command);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800618 ~CommandEntry();
619
620 Command command;
621
622 // parameters for the command (usage varies by command)
623 sp<Connection> connection;
624 nsecs_t eventTime;
625 KeyEntry* keyEntry;
626 sp<InputApplicationHandle> inputApplicationHandle;
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -0800627 std::string reason;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800628 int32_t userActivityEventType;
629 uint32_t seq;
630 bool handled;
Robert Carr803535b2018-08-02 16:38:15 -0700631 sp<InputChannel> inputChannel;
Robert Carrf759f162018-11-13 12:57:11 -0800632 sp<IBinder> token;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800633 };
634
635 // Generic queue implementation.
636 template <typename T>
637 struct Queue {
638 T* head;
639 T* tail;
Jon McCaffrey65dbe972014-11-18 12:07:08 -0800640 uint32_t entryCount;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800641
Yi Kong9b14ac62018-07-17 13:48:38 -0700642 inline Queue() : head(nullptr), tail(nullptr), entryCount(0) {
Michael Wrightd02c5b62014-02-10 15:10:22 -0800643 }
644
645 inline bool isEmpty() const {
646 return !head;
647 }
648
649 inline void enqueueAtTail(T* entry) {
Jon McCaffrey65dbe972014-11-18 12:07:08 -0800650 entryCount++;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800651 entry->prev = tail;
652 if (tail) {
653 tail->next = entry;
654 } else {
655 head = entry;
656 }
Yi Kong9b14ac62018-07-17 13:48:38 -0700657 entry->next = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800658 tail = entry;
659 }
660
661 inline void enqueueAtHead(T* entry) {
Jon McCaffrey65dbe972014-11-18 12:07:08 -0800662 entryCount++;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800663 entry->next = head;
664 if (head) {
665 head->prev = entry;
666 } else {
667 tail = entry;
668 }
Yi Kong9b14ac62018-07-17 13:48:38 -0700669 entry->prev = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800670 head = entry;
671 }
672
673 inline void dequeue(T* entry) {
Jon McCaffrey65dbe972014-11-18 12:07:08 -0800674 entryCount--;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800675 if (entry->prev) {
676 entry->prev->next = entry->next;
677 } else {
678 head = entry->next;
679 }
680 if (entry->next) {
681 entry->next->prev = entry->prev;
682 } else {
683 tail = entry->prev;
684 }
685 }
686
687 inline T* dequeueAtHead() {
Jon McCaffrey65dbe972014-11-18 12:07:08 -0800688 entryCount--;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800689 T* entry = head;
690 head = entry->next;
691 if (head) {
Yi Kong9b14ac62018-07-17 13:48:38 -0700692 head->prev = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800693 } else {
Yi Kong9b14ac62018-07-17 13:48:38 -0700694 tail = nullptr;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800695 }
696 return entry;
697 }
698
Jon McCaffrey65dbe972014-11-18 12:07:08 -0800699 uint32_t count() const {
700 return entryCount;
701 }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800702 };
703
704 /* Specifies which events are to be canceled and why. */
705 struct CancelationOptions {
706 enum Mode {
707 CANCEL_ALL_EVENTS = 0,
708 CANCEL_POINTER_EVENTS = 1,
709 CANCEL_NON_POINTER_EVENTS = 2,
710 CANCEL_FALLBACK_EVENTS = 3,
Tiger Huang721e26f2018-07-24 22:26:19 +0800711
712 /* Cancel events where the display not specified. These events would go to the focused
713 * display. */
714 CANCEL_DISPLAY_UNSPECIFIED_EVENTS = 4,
Michael Wrightd02c5b62014-02-10 15:10:22 -0800715 };
716
717 // The criterion to use to determine which events should be canceled.
718 Mode mode;
719
720 // Descriptive reason for the cancelation.
721 const char* reason;
722
723 // The specific keycode of the key event to cancel, or -1 to cancel any key event.
724 int32_t keyCode;
725
726 // The specific device id of events to cancel, or -1 to cancel events from any device.
727 int32_t deviceId;
728
729 CancelationOptions(Mode mode, const char* reason) :
730 mode(mode), reason(reason), keyCode(-1), deviceId(-1) { }
731 };
732
733 /* Tracks dispatched key and motion event state so that cancelation events can be
734 * synthesized when events are dropped. */
735 class InputState {
736 public:
737 InputState();
738 ~InputState();
739
740 // Returns true if there is no state to be canceled.
741 bool isNeutral() const;
742
743 // Returns true if the specified source is known to have received a hover enter
744 // motion event.
745 bool isHovering(int32_t deviceId, uint32_t source, int32_t displayId) const;
746
747 // Records tracking information for a key event that has just been published.
748 // Returns true if the event should be delivered, false if it is inconsistent
749 // and should be skipped.
750 bool trackKey(const KeyEntry* entry, int32_t action, int32_t flags);
751
752 // Records tracking information for a motion event that has just been published.
753 // Returns true if the event should be delivered, false if it is inconsistent
754 // and should be skipped.
755 bool trackMotion(const MotionEntry* entry, int32_t action, int32_t flags);
756
757 // Synthesizes cancelation events for the current state and resets the tracked state.
758 void synthesizeCancelationEvents(nsecs_t currentTime,
759 Vector<EventEntry*>& outEvents, const CancelationOptions& options);
760
761 // Clears the current state.
762 void clear();
763
764 // Copies pointer-related parts of the input state to another instance.
765 void copyPointerStateTo(InputState& other) const;
766
767 // Gets the fallback key associated with a keycode.
768 // Returns -1 if none.
769 // Returns AKEYCODE_UNKNOWN if we are only dispatching the unhandled key to the policy.
770 int32_t getFallbackKey(int32_t originalKeyCode);
771
772 // Sets the fallback key for a particular keycode.
773 void setFallbackKey(int32_t originalKeyCode, int32_t fallbackKeyCode);
774
775 // Removes the fallback key for a particular keycode.
776 void removeFallbackKey(int32_t originalKeyCode);
777
778 inline const KeyedVector<int32_t, int32_t>& getFallbackKeys() const {
779 return mFallbackKeys;
780 }
781
782 private:
783 struct KeyMemento {
784 int32_t deviceId;
785 uint32_t source;
Siarhei Vishniakoua62a8dd2018-06-08 21:17:33 +0100786 int32_t displayId;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800787 int32_t keyCode;
788 int32_t scanCode;
789 int32_t metaState;
790 int32_t flags;
791 nsecs_t downTime;
792 uint32_t policyFlags;
793 };
794
795 struct MotionMemento {
796 int32_t deviceId;
797 uint32_t source;
Siarhei Vishniakou777a10b2018-01-31 16:45:06 -0800798 int32_t displayId;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800799 int32_t flags;
800 float xPrecision;
801 float yPrecision;
802 nsecs_t downTime;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800803 uint32_t pointerCount;
804 PointerProperties pointerProperties[MAX_POINTERS];
805 PointerCoords pointerCoords[MAX_POINTERS];
806 bool hovering;
807 uint32_t policyFlags;
808
809 void setPointers(const MotionEntry* entry);
810 };
811
812 Vector<KeyMemento> mKeyMementos;
813 Vector<MotionMemento> mMotionMementos;
814 KeyedVector<int32_t, int32_t> mFallbackKeys;
815
816 ssize_t findKeyMemento(const KeyEntry* entry) const;
817 ssize_t findMotionMemento(const MotionEntry* entry, bool hovering) const;
818
819 void addKeyMemento(const KeyEntry* entry, int32_t flags);
820 void addMotionMemento(const MotionEntry* entry, int32_t flags, bool hovering);
821
822 static bool shouldCancelKey(const KeyMemento& memento,
823 const CancelationOptions& options);
824 static bool shouldCancelMotion(const MotionMemento& memento,
825 const CancelationOptions& options);
826 };
827
828 /* Manages the dispatch state associated with a single input channel. */
829 class Connection : public RefBase {
830 protected:
831 virtual ~Connection();
832
833 public:
834 enum Status {
835 // Everything is peachy.
836 STATUS_NORMAL,
837 // An unrecoverable communication error has occurred.
838 STATUS_BROKEN,
839 // The input channel has been unregistered.
840 STATUS_ZOMBIE
841 };
842
843 Status status;
844 sp<InputChannel> inputChannel; // never null
Michael Wrightd02c5b62014-02-10 15:10:22 -0800845 bool monitor;
846 InputPublisher inputPublisher;
847 InputState inputState;
848
849 // True if the socket is full and no further events can be published until
850 // the application consumes some of the input.
851 bool inputPublisherBlocked;
852
853 // Queue of events that need to be published to the connection.
854 Queue<DispatchEntry> outboundQueue;
855
856 // Queue of events that have been published to the connection but that have not
857 // yet received a "finished" response from the application.
858 Queue<DispatchEntry> waitQueue;
859
Robert Carr803535b2018-08-02 16:38:15 -0700860 explicit Connection(const sp<InputChannel>& inputChannel, bool monitor);
Michael Wrightd02c5b62014-02-10 15:10:22 -0800861
Siarhei Vishniakou587c3f02018-01-04 11:46:44 -0800862 inline const std::string getInputChannelName() const { return inputChannel->getName(); }
Michael Wrightd02c5b62014-02-10 15:10:22 -0800863
Siarhei Vishniakou587c3f02018-01-04 11:46:44 -0800864 const std::string getWindowName() const;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800865 const char* getStatusLabel() const;
866
867 DispatchEntry* findWaitQueueEntry(uint32_t seq);
868 };
869
870 enum DropReason {
871 DROP_REASON_NOT_DROPPED = 0,
872 DROP_REASON_POLICY = 1,
873 DROP_REASON_APP_SWITCH = 2,
874 DROP_REASON_DISABLED = 3,
875 DROP_REASON_BLOCKED = 4,
876 DROP_REASON_STALE = 5,
877 };
878
879 sp<InputDispatcherPolicyInterface> mPolicy;
880 InputDispatcherConfiguration mConfig;
881
882 Mutex mLock;
883
884 Condition mDispatcherIsAliveCondition;
885
886 sp<Looper> mLooper;
887
888 EventEntry* mPendingEvent;
889 Queue<EventEntry> mInboundQueue;
890 Queue<EventEntry> mRecentQueue;
891 Queue<CommandEntry> mCommandQueue;
892
Michael Wright3a981722015-06-10 15:26:13 +0100893 DropReason mLastDropReason;
894
Michael Wrightd02c5b62014-02-10 15:10:22 -0800895 void dispatchOnceInnerLocked(nsecs_t* nextWakeupTime);
896
897 // Enqueues an inbound event. Returns true if mLooper->wake() should be called.
898 bool enqueueInboundEventLocked(EventEntry* entry);
899
900 // Cleans up input state when dropping an inbound event.
901 void dropInboundEventLocked(EventEntry* entry, DropReason dropReason);
902
903 // Adds an event to a queue of recent events for debugging purposes.
904 void addRecentEventLocked(EventEntry* entry);
905
906 // App switch latency optimization.
907 bool mAppSwitchSawKeyDown;
908 nsecs_t mAppSwitchDueTime;
909
910 static bool isAppSwitchKeyCode(int32_t keyCode);
911 bool isAppSwitchKeyEventLocked(KeyEntry* keyEntry);
912 bool isAppSwitchPendingLocked();
913 void resetPendingAppSwitchLocked(bool handled);
914
915 // Stale event latency optimization.
916 static bool isStaleEventLocked(nsecs_t currentTime, EventEntry* entry);
917
918 // Blocked event latency optimization. Drops old events when the user intends
919 // to transfer focus to a new application.
920 EventEntry* mNextUnblockedEvent;
921
922 sp<InputWindowHandle> findTouchedWindowAtLocked(int32_t displayId, int32_t x, int32_t y);
923
924 // All registered connections mapped by channel file descriptor.
925 KeyedVector<int, sp<Connection> > mConnectionsByFd;
926
Robert Carr5c8a0262018-10-03 16:30:44 -0700927 struct IBinderHash {
928 std::size_t operator()(const sp<IBinder>& b) const {
929 return std::hash<IBinder *>{}(b.get());
930 }
931 };
932 std::unordered_map<sp<IBinder>, sp<InputChannel>, IBinderHash> mInputChannelsByToken;
933
Michael Wrightd02c5b62014-02-10 15:10:22 -0800934 ssize_t getConnectionIndexLocked(const sp<InputChannel>& inputChannel);
935
Arthur Hung2fbf37f2018-09-13 18:16:41 +0800936 // Input channels that will receive a copy of all input events sent to the provided display.
937 std::unordered_map<int32_t, Vector<sp<InputChannel>>> mMonitoringChannelsByDisplay;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800938
939 // Event injection and synchronization.
940 Condition mInjectionResultAvailableCondition;
941 bool hasInjectionPermission(int32_t injectorPid, int32_t injectorUid);
942 void setInjectionResultLocked(EventEntry* entry, int32_t injectionResult);
943
944 Condition mInjectionSyncFinishedCondition;
945 void incrementPendingForegroundDispatchesLocked(EventEntry* entry);
946 void decrementPendingForegroundDispatchesLocked(EventEntry* entry);
947
948 // Key repeat tracking.
949 struct KeyRepeatState {
950 KeyEntry* lastKeyEntry; // or null if no repeat
951 nsecs_t nextRepeatTime;
952 } mKeyRepeatState;
953
954 void resetKeyRepeatLocked();
955 KeyEntry* synthesizeKeyRepeatLocked(nsecs_t currentTime);
956
Michael Wright78f24442014-08-06 15:55:28 -0700957 // Key replacement tracking
958 struct KeyReplacement {
959 int32_t keyCode;
960 int32_t deviceId;
961 bool operator==(const KeyReplacement& rhs) const {
962 return keyCode == rhs.keyCode && deviceId == rhs.deviceId;
963 }
964 bool operator<(const KeyReplacement& rhs) const {
965 return keyCode != rhs.keyCode ? keyCode < rhs.keyCode : deviceId < rhs.deviceId;
966 }
967 };
968 // Maps the key code replaced, device id tuple to the key code it was replaced with
969 KeyedVector<KeyReplacement, int32_t> mReplacedKeys;
Siarhei Vishniakou61fafdd2018-04-13 11:00:58 -0500970 // Process certain Meta + Key combinations
971 void accelerateMetaShortcuts(const int32_t deviceId, const int32_t action,
972 int32_t& keyCode, int32_t& metaState);
Michael Wright78f24442014-08-06 15:55:28 -0700973
Michael Wrightd02c5b62014-02-10 15:10:22 -0800974 // Deferred command processing.
975 bool haveCommandsLocked() const;
976 bool runCommandsLockedInterruptible();
977 CommandEntry* postCommandLocked(Command command);
978
979 // Input filter processing.
980 bool shouldSendKeyToInputFilterLocked(const NotifyKeyArgs* args);
981 bool shouldSendMotionToInputFilterLocked(const NotifyMotionArgs* args);
982
983 // Inbound event processing.
984 void drainInboundQueueLocked();
985 void releasePendingEventLocked();
986 void releaseInboundEventLocked(EventEntry* entry);
987
988 // Dispatch state.
989 bool mDispatchEnabled;
990 bool mDispatchFrozen;
991 bool mInputFilterEnabled;
992
Arthur Hungb92218b2018-08-14 12:00:21 +0800993 std::unordered_map<int32_t, Vector<sp<InputWindowHandle>>> mWindowHandlesByDisplay;
994 // Get window handles by display, return an empty vector if not found.
995 Vector<sp<InputWindowHandle>> getWindowHandlesLocked(int32_t displayId) const;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800996 sp<InputWindowHandle> getWindowHandleLocked(const sp<InputChannel>& inputChannel) const;
Robert Carr5c8a0262018-10-03 16:30:44 -0700997 sp<InputChannel> getInputChannelLocked(const sp<IBinder>& windowToken) const;
Siarhei Vishniakou9224fba2018-08-13 18:55:08 +0000998 bool hasWindowHandleLocked(const sp<InputWindowHandle>& windowHandle) const;
Michael Wrightd02c5b62014-02-10 15:10:22 -0800999
1000 // Focus tracking for keys, trackball, etc.
Tiger Huang721e26f2018-07-24 22:26:19 +08001001 std::unordered_map<int32_t, sp<InputWindowHandle>> mFocusedWindowHandlesByDisplay;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001002
1003 // Focus tracking for touch.
1004 struct TouchedWindow {
1005 sp<InputWindowHandle> windowHandle;
1006 int32_t targetFlags;
1007 BitSet32 pointerIds; // zero unless target flag FLAG_SPLIT is set
1008 };
1009 struct TouchState {
1010 bool down;
1011 bool split;
1012 int32_t deviceId; // id of the device that is currently down, others are rejected
1013 uint32_t source; // source of the device that is current down, others are rejected
1014 int32_t displayId; // id to the display that currently has a touch, others are rejected
1015 Vector<TouchedWindow> windows;
1016
1017 TouchState();
1018 ~TouchState();
1019 void reset();
1020 void copyFrom(const TouchState& other);
1021 void addOrUpdateWindow(const sp<InputWindowHandle>& windowHandle,
1022 int32_t targetFlags, BitSet32 pointerIds);
1023 void removeWindow(const sp<InputWindowHandle>& windowHandle);
Robert Carr803535b2018-08-02 16:38:15 -07001024 void removeWindowByToken(const sp<IBinder>& token);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001025 void filterNonAsIsTouchWindows();
1026 sp<InputWindowHandle> getFirstForegroundWindowHandle() const;
1027 bool isSlippery() const;
1028 };
1029
Jeff Brownf086ddb2014-02-11 14:28:48 -08001030 KeyedVector<int32_t, TouchState> mTouchStatesByDisplay;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001031 TouchState mTempTouchState;
1032
Tiger Huang721e26f2018-07-24 22:26:19 +08001033 // Focused applications.
1034 std::unordered_map<int32_t, sp<InputApplicationHandle>> mFocusedApplicationHandlesByDisplay;
1035
1036 // Top focused display.
1037 int32_t mFocusedDisplayId;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001038
1039 // Dispatcher state at time of last ANR.
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08001040 std::string mLastANRState;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001041
1042 // Dispatch inbound events.
1043 bool dispatchConfigurationChangedLocked(
1044 nsecs_t currentTime, ConfigurationChangedEntry* entry);
1045 bool dispatchDeviceResetLocked(
1046 nsecs_t currentTime, DeviceResetEntry* entry);
1047 bool dispatchKeyLocked(
1048 nsecs_t currentTime, KeyEntry* entry,
1049 DropReason* dropReason, nsecs_t* nextWakeupTime);
1050 bool dispatchMotionLocked(
1051 nsecs_t currentTime, MotionEntry* entry,
1052 DropReason* dropReason, nsecs_t* nextWakeupTime);
1053 void dispatchEventLocked(nsecs_t currentTime, EventEntry* entry,
1054 const Vector<InputTarget>& inputTargets);
1055
1056 void logOutboundKeyDetailsLocked(const char* prefix, const KeyEntry* entry);
1057 void logOutboundMotionDetailsLocked(const char* prefix, const MotionEntry* entry);
1058
1059 // Keeping track of ANR timeouts.
1060 enum InputTargetWaitCause {
1061 INPUT_TARGET_WAIT_CAUSE_NONE,
1062 INPUT_TARGET_WAIT_CAUSE_SYSTEM_NOT_READY,
1063 INPUT_TARGET_WAIT_CAUSE_APPLICATION_NOT_READY,
1064 };
1065
1066 InputTargetWaitCause mInputTargetWaitCause;
1067 nsecs_t mInputTargetWaitStartTime;
1068 nsecs_t mInputTargetWaitTimeoutTime;
1069 bool mInputTargetWaitTimeoutExpired;
Robert Carr740167f2018-10-11 19:03:41 -07001070 sp<IBinder> mInputTargetWaitApplicationToken;
Michael Wrightd02c5b62014-02-10 15:10:22 -08001071
1072 // Contains the last window which received a hover event.
1073 sp<InputWindowHandle> mLastHoverWindowHandle;
1074
1075 // Finding targets for input events.
1076 int32_t handleTargetsNotReadyLocked(nsecs_t currentTime, const EventEntry* entry,
1077 const sp<InputApplicationHandle>& applicationHandle,
1078 const sp<InputWindowHandle>& windowHandle,
1079 nsecs_t* nextWakeupTime, const char* reason);
Robert Carr803535b2018-08-02 16:38:15 -07001080
1081 void removeWindowByTokenLocked(const sp<IBinder>& token);
1082
Michael Wrightd02c5b62014-02-10 15:10:22 -08001083 void resumeAfterTargetsNotReadyTimeoutLocked(nsecs_t newTimeout,
1084 const sp<InputChannel>& inputChannel);
1085 nsecs_t getTimeSpentWaitingForApplicationLocked(nsecs_t currentTime);
1086 void resetANRTimeoutsLocked();
1087
Tiger Huang721e26f2018-07-24 22:26:19 +08001088 int32_t getTargetDisplayId(const EventEntry* entry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001089 int32_t findFocusedWindowTargetsLocked(nsecs_t currentTime, const EventEntry* entry,
1090 Vector<InputTarget>& inputTargets, nsecs_t* nextWakeupTime);
1091 int32_t findTouchedWindowTargetsLocked(nsecs_t currentTime, const MotionEntry* entry,
1092 Vector<InputTarget>& inputTargets, nsecs_t* nextWakeupTime,
1093 bool* outConflictingPointerActions);
1094
1095 void addWindowTargetLocked(const sp<InputWindowHandle>& windowHandle,
1096 int32_t targetFlags, BitSet32 pointerIds, Vector<InputTarget>& inputTargets);
Arthur Hung2fbf37f2018-09-13 18:16:41 +08001097 void addMonitoringTargetsLocked(Vector<InputTarget>& inputTargets, int32_t displayId);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001098
1099 void pokeUserActivityLocked(const EventEntry* eventEntry);
1100 bool checkInjectionPermission(const sp<InputWindowHandle>& windowHandle,
1101 const InjectionState* injectionState);
1102 bool isWindowObscuredAtPointLocked(const sp<InputWindowHandle>& windowHandle,
1103 int32_t x, int32_t y) const;
Michael Wrightcdcd8f22016-03-22 16:52:13 -07001104 bool isWindowObscuredLocked(const sp<InputWindowHandle>& windowHandle) const;
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08001105 std::string getApplicationWindowLabelLocked(const sp<InputApplicationHandle>& applicationHandle,
Michael Wrightd02c5b62014-02-10 15:10:22 -08001106 const sp<InputWindowHandle>& windowHandle);
1107
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08001108 std::string checkWindowReadyForMoreInputLocked(nsecs_t currentTime,
Jeff Brownffb49772014-10-10 19:01:34 -07001109 const sp<InputWindowHandle>& windowHandle, const EventEntry* eventEntry,
1110 const char* targetType);
1111
Michael Wrightd02c5b62014-02-10 15:10:22 -08001112 // Manage the dispatch cycle for a single connection.
1113 // These methods are deliberately not Interruptible because doing all of the work
1114 // with the mutex held makes it easier to ensure that connection invariants are maintained.
1115 // If needed, the methods post commands to run later once the critical bits are done.
1116 void prepareDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,
1117 EventEntry* eventEntry, const InputTarget* inputTarget);
1118 void enqueueDispatchEntriesLocked(nsecs_t currentTime, const sp<Connection>& connection,
1119 EventEntry* eventEntry, const InputTarget* inputTarget);
1120 void enqueueDispatchEntryLocked(const sp<Connection>& connection,
1121 EventEntry* eventEntry, const InputTarget* inputTarget, int32_t dispatchMode);
1122 void startDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection);
1123 void finishDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,
1124 uint32_t seq, bool handled);
1125 void abortBrokenDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,
1126 bool notify);
1127 void drainDispatchQueueLocked(Queue<DispatchEntry>* queue);
1128 void releaseDispatchEntryLocked(DispatchEntry* dispatchEntry);
1129 static int handleReceiveCallback(int fd, int events, void* data);
1130
1131 void synthesizeCancelationEventsForAllConnectionsLocked(
1132 const CancelationOptions& options);
Michael Wrightfa13dcf2015-06-12 13:25:11 +01001133 void synthesizeCancelationEventsForMonitorsLocked(const CancelationOptions& options);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001134 void synthesizeCancelationEventsForInputChannelLocked(const sp<InputChannel>& channel,
1135 const CancelationOptions& options);
1136 void synthesizeCancelationEventsForConnectionLocked(const sp<Connection>& connection,
1137 const CancelationOptions& options);
1138
1139 // Splitting motion events across windows.
1140 MotionEntry* splitMotionEvent(const MotionEntry* originalMotionEntry, BitSet32 pointerIds);
1141
1142 // Reset and drop everything the dispatcher is doing.
1143 void resetAndDropEverythingLocked(const char* reason);
1144
1145 // Dump state.
Siarhei Vishniakouf93fcf42017-11-22 16:00:14 -08001146 void dumpDispatchStateLocked(std::string& dump);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001147 void logDispatchStateLocked();
1148
1149 // Registration.
1150 void removeMonitorChannelLocked(const sp<InputChannel>& inputChannel);
1151 status_t unregisterInputChannelLocked(const sp<InputChannel>& inputChannel, bool notify);
1152
1153 // Add or remove a connection to the mActiveConnections vector.
1154 void activateConnectionLocked(Connection* connection);
1155 void deactivateConnectionLocked(Connection* connection);
1156
1157 // Interesting events that we might like to log or tell the framework about.
1158 void onDispatchCycleFinishedLocked(
1159 nsecs_t currentTime, const sp<Connection>& connection, uint32_t seq, bool handled);
1160 void onDispatchCycleBrokenLocked(
1161 nsecs_t currentTime, const sp<Connection>& connection);
Robert Carrf759f162018-11-13 12:57:11 -08001162 void onFocusChangedLocked(const sp<InputWindowHandle>& newFocus);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001163 void onANRLocked(
1164 nsecs_t currentTime, const sp<InputApplicationHandle>& applicationHandle,
1165 const sp<InputWindowHandle>& windowHandle,
1166 nsecs_t eventTime, nsecs_t waitStartTime, const char* reason);
1167
1168 // Outbound policy interactions.
1169 void doNotifyConfigurationChangedInterruptible(CommandEntry* commandEntry);
1170 void doNotifyInputChannelBrokenLockedInterruptible(CommandEntry* commandEntry);
Robert Carrf759f162018-11-13 12:57:11 -08001171 void doNotifyFocusChangedLockedInterruptible(CommandEntry* commandEntry);
Michael Wrightd02c5b62014-02-10 15:10:22 -08001172 void doNotifyANRLockedInterruptible(CommandEntry* commandEntry);
1173 void doInterceptKeyBeforeDispatchingLockedInterruptible(CommandEntry* commandEntry);
1174 void doDispatchCycleFinishedLockedInterruptible(CommandEntry* commandEntry);
1175 bool afterKeyEventLockedInterruptible(const sp<Connection>& connection,
1176 DispatchEntry* dispatchEntry, KeyEntry* keyEntry, bool handled);
1177 bool afterMotionEventLockedInterruptible(const sp<Connection>& connection,
1178 DispatchEntry* dispatchEntry, MotionEntry* motionEntry, bool handled);
1179 void doPokeUserActivityLockedInterruptible(CommandEntry* commandEntry);
1180 void initializeKeyEvent(KeyEvent* event, const KeyEntry* entry);
1181
1182 // Statistics gathering.
1183 void updateDispatchStatisticsLocked(nsecs_t currentTime, const EventEntry* entry,
1184 int32_t injectionResult, nsecs_t timeSpentWaitingForApplication);
1185 void traceInboundQueueLengthLocked();
1186 void traceOutboundQueueLengthLocked(const sp<Connection>& connection);
1187 void traceWaitQueueLengthLocked(const sp<Connection>& connection);
1188};
1189
1190/* Enqueues and dispatches input events, endlessly. */
1191class InputDispatcherThread : public Thread {
1192public:
1193 explicit InputDispatcherThread(const sp<InputDispatcherInterface>& dispatcher);
1194 ~InputDispatcherThread();
1195
1196private:
1197 virtual bool threadLoop();
1198
1199 sp<InputDispatcherInterface> mDispatcher;
1200};
1201
1202} // namespace android
1203
1204#endif // _UI_INPUT_DISPATCHER_H