blob: 430721e85d13f70bbf258c7f53e0b620c22f0641 [file] [log] [blame]
Jeff Brown46b9ac02010-04-22 18:58:52 -07001/*
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
Mathias Agopianb93a03f82012-02-17 15:34:57 -080020#include <androidfw/Input.h>
21#include <androidfw/InputTransport.h>
Jeff Brown46b9ac02010-04-22 18:58:52 -070022#include <utils/KeyedVector.h>
23#include <utils/Vector.h>
24#include <utils/threads.h>
25#include <utils/Timers.h>
26#include <utils/RefBase.h>
27#include <utils/String8.h>
Jeff Brown4fe6c3e2010-09-13 23:17:30 -070028#include <utils/Looper.h>
Jeff Brown01ce2e92010-09-26 22:20:12 -070029#include <utils/BitSet.h>
Jeff Brown072ec962012-02-07 14:46:57 -080030#include <cutils/atomic.h>
Jeff Brown46b9ac02010-04-22 18:58:52 -070031
32#include <stddef.h>
33#include <unistd.h>
Jeff Brownb88102f2010-09-08 11:49:43 -070034#include <limits.h>
Jeff Brown46b9ac02010-04-22 18:58:52 -070035
Jeff Brown928e0542011-01-10 11:17:36 -080036#include "InputWindow.h"
37#include "InputApplication.h"
Jeff Brownbe1aa822011-07-27 16:04:54 -070038#include "InputListener.h"
Jeff Brown928e0542011-01-10 11:17:36 -080039
Jeff Brown46b9ac02010-04-22 18:58:52 -070040
41namespace android {
42
Jeff Brown9c3cda02010-06-15 01:31:58 -070043/*
Jeff Brown7fbdc842010-06-17 20:52:56 -070044 * Constants used to report the outcome of input event injection.
45 */
46enum {
47 /* (INTERNAL USE ONLY) Specifies that injection is pending and its outcome is unknown. */
48 INPUT_EVENT_INJECTION_PENDING = -1,
49
50 /* Injection succeeded. */
51 INPUT_EVENT_INJECTION_SUCCEEDED = 0,
52
53 /* Injection failed because the injector did not have permission to inject
54 * into the application with input focus. */
55 INPUT_EVENT_INJECTION_PERMISSION_DENIED = 1,
56
57 /* Injection failed because there were no available input targets. */
58 INPUT_EVENT_INJECTION_FAILED = 2,
59
60 /* Injection failed due to a timeout. */
61 INPUT_EVENT_INJECTION_TIMED_OUT = 3
62};
63
Jeff Brown6ec402b2010-07-28 15:48:59 -070064/*
65 * Constants used to determine the input event injection synchronization mode.
66 */
67enum {
68 /* Injection is asynchronous and is assumed always to be successful. */
69 INPUT_EVENT_INJECTION_SYNC_NONE = 0,
70
71 /* Waits for previous events to be dispatched so that the input dispatcher can determine
72 * whether input event injection willbe permitted based on the current input focus.
73 * Does not wait for the input event to finish processing. */
74 INPUT_EVENT_INJECTION_SYNC_WAIT_FOR_RESULT = 1,
75
76 /* Waits for the input event to be completely processed. */
77 INPUT_EVENT_INJECTION_SYNC_WAIT_FOR_FINISHED = 2,
78};
79
Jeff Brown7fbdc842010-06-17 20:52:56 -070080
81/*
Jeff Brown9c3cda02010-06-15 01:31:58 -070082 * An input target specifies how an input event is to be dispatched to a particular window
83 * including the window's input channel, control flags, a timeout, and an X / Y offset to
84 * be added to input event coordinates to compensate for the absolute position of the
85 * window area.
86 */
87struct InputTarget {
88 enum {
Jeff Brown519e0242010-09-15 15:18:56 -070089 /* This flag indicates that the event is being delivered to a foreground application. */
Jeff Browna032cc02011-03-07 16:56:21 -080090 FLAG_FOREGROUND = 1 << 0,
Jeff Brown9c3cda02010-06-15 01:31:58 -070091
Jeff Brown85a31762010-09-01 17:01:00 -070092 /* This flag indicates that the target of a MotionEvent is partly or wholly
93 * obscured by another visible window above it. The motion event should be
94 * delivered with flag AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED. */
Jeff Browna032cc02011-03-07 16:56:21 -080095 FLAG_WINDOW_IS_OBSCURED = 1 << 1,
Jeff Brown01ce2e92010-09-26 22:20:12 -070096
97 /* This flag indicates that a motion event is being split across multiple windows. */
Jeff Browna032cc02011-03-07 16:56:21 -080098 FLAG_SPLIT = 1 << 2,
99
Kenny Root7a9db182011-06-02 15:16:05 -0700100 /* This flag indicates that the pointer coordinates dispatched to the application
101 * will be zeroed out to avoid revealing information to an application. This is
102 * used in conjunction with FLAG_DISPATCH_AS_OUTSIDE to prevent apps not sharing
103 * the same UID from watching all touches. */
104 FLAG_ZERO_COORDS = 1 << 3,
105
Jeff Browna032cc02011-03-07 16:56:21 -0800106 /* This flag indicates that the event should be sent as is.
107 * Should always be set unless the event is to be transmuted. */
108 FLAG_DISPATCH_AS_IS = 1 << 8,
109
110 /* This flag indicates that a MotionEvent with AMOTION_EVENT_ACTION_DOWN falls outside
111 * of the area of this target and so should instead be delivered as an
112 * AMOTION_EVENT_ACTION_OUTSIDE to this target. */
113 FLAG_DISPATCH_AS_OUTSIDE = 1 << 9,
114
115 /* This flag indicates that a hover sequence is starting in the given window.
116 * The event is transmuted into ACTION_HOVER_ENTER. */
117 FLAG_DISPATCH_AS_HOVER_ENTER = 1 << 10,
118
119 /* This flag indicates that a hover event happened outside of a window which handled
120 * previous hover events, signifying the end of the current hover sequence for that
121 * window.
122 * The event is transmuted into ACTION_HOVER_ENTER. */
123 FLAG_DISPATCH_AS_HOVER_EXIT = 1 << 11,
124
Jeff Brown98db5fa2011-06-08 15:37:10 -0700125 /* This flag indicates that the event should be canceled.
126 * It is used to transmute ACTION_MOVE into ACTION_CANCEL when a touch slips
127 * outside of a window. */
128 FLAG_DISPATCH_AS_SLIPPERY_EXIT = 1 << 12,
129
130 /* This flag indicates that the event should be dispatched as an initial down.
131 * It is used to transmute ACTION_MOVE into ACTION_DOWN when a touch slips
132 * into a new window. */
133 FLAG_DISPATCH_AS_SLIPPERY_ENTER = 1 << 13,
134
Jeff Browna032cc02011-03-07 16:56:21 -0800135 /* Mask for all dispatch modes. */
136 FLAG_DISPATCH_MASK = FLAG_DISPATCH_AS_IS
137 | FLAG_DISPATCH_AS_OUTSIDE
138 | FLAG_DISPATCH_AS_HOVER_ENTER
Jeff Brown98db5fa2011-06-08 15:37:10 -0700139 | FLAG_DISPATCH_AS_HOVER_EXIT
140 | FLAG_DISPATCH_AS_SLIPPERY_EXIT
141 | FLAG_DISPATCH_AS_SLIPPERY_ENTER,
Jeff Brown9c3cda02010-06-15 01:31:58 -0700142 };
143
144 // The input channel to be targeted.
145 sp<InputChannel> inputChannel;
146
147 // Flags for the input target.
148 int32_t flags;
149
Jeff Brown9c3cda02010-06-15 01:31:58 -0700150 // The x and y offset to add to a MotionEvent as it is delivered.
151 // (ignored for KeyEvents)
152 float xOffset, yOffset;
Jeff Brown01ce2e92010-09-26 22:20:12 -0700153
Dianne Hackborne2515ee2011-04-27 18:52:56 -0400154 // Scaling factor to apply to MotionEvent as it is delivered.
155 // (ignored for KeyEvents)
156 float scaleFactor;
157
Jeff Brown01ce2e92010-09-26 22:20:12 -0700158 // The subset of pointer ids to include in motion events dispatched to this input target
159 // if FLAG_SPLIT is set.
160 BitSet32 pointerIds;
Jeff Brown9c3cda02010-06-15 01:31:58 -0700161};
162
Jeff Brown7fbdc842010-06-17 20:52:56 -0700163
Jeff Brown9c3cda02010-06-15 01:31:58 -0700164/*
Jeff Brown214eaf42011-05-26 19:17:02 -0700165 * Input dispatcher configuration.
166 *
167 * Specifies various options that modify the behavior of the input dispatcher.
Michael Wright40f8f0d12013-03-26 13:11:30 -0700168 * The values provided here are merely defaults. The actual values will come from ViewConfiguration
169 * and are passed into the dispatcher during initialization.
Jeff Brown214eaf42011-05-26 19:17:02 -0700170 */
171struct InputDispatcherConfiguration {
172 // The key repeat initial timeout.
173 nsecs_t keyRepeatTimeout;
174
175 // The key repeat inter-key delay.
176 nsecs_t keyRepeatDelay;
177
Jeff Brown214eaf42011-05-26 19:17:02 -0700178 InputDispatcherConfiguration() :
179 keyRepeatTimeout(500 * 1000000LL),
Jeff Brown30802802012-02-03 13:35:13 -0800180 keyRepeatDelay(50 * 1000000LL) { }
Jeff Brown214eaf42011-05-26 19:17:02 -0700181};
182
183
184/*
Jeff Brown9c3cda02010-06-15 01:31:58 -0700185 * Input dispatcher policy interface.
186 *
187 * The input reader policy is used by the input reader to interact with the Window Manager
188 * and other system components.
189 *
190 * The actual implementation is partially supported by callbacks into the DVM
191 * via JNI. This interface is also mocked in the unit tests.
192 */
193class InputDispatcherPolicyInterface : public virtual RefBase {
194protected:
195 InputDispatcherPolicyInterface() { }
196 virtual ~InputDispatcherPolicyInterface() { }
197
198public:
199 /* Notifies the system that a configuration change has occurred. */
200 virtual void notifyConfigurationChanged(nsecs_t when) = 0;
201
Jeff Brownb88102f2010-09-08 11:49:43 -0700202 /* Notifies the system that an application is not responding.
203 * Returns a new timeout to continue waiting, or 0 to abort dispatch. */
Jeff Brown519e0242010-09-15 15:18:56 -0700204 virtual nsecs_t notifyANR(const sp<InputApplicationHandle>& inputApplicationHandle,
Jeff Brown928e0542011-01-10 11:17:36 -0800205 const sp<InputWindowHandle>& inputWindowHandle) = 0;
Jeff Brownb88102f2010-09-08 11:49:43 -0700206
Jeff Brown9c3cda02010-06-15 01:31:58 -0700207 /* Notifies the system that an input channel is unrecoverably broken. */
Jeff Brown928e0542011-01-10 11:17:36 -0800208 virtual void notifyInputChannelBroken(const sp<InputWindowHandle>& inputWindowHandle) = 0;
Jeff Brown9c3cda02010-06-15 01:31:58 -0700209
Jeff Brown214eaf42011-05-26 19:17:02 -0700210 /* Gets the input dispatcher configuration. */
211 virtual void getDispatcherConfiguration(InputDispatcherConfiguration* outConfig) = 0;
Jeff Brown9c3cda02010-06-15 01:31:58 -0700212
Jeff Brown214eaf42011-05-26 19:17:02 -0700213 /* Returns true if automatic key repeating is enabled. */
214 virtual bool isKeyRepeatEnabled() = 0;
Jeff Brownb88102f2010-09-08 11:49:43 -0700215
Jeff Brown0029c662011-03-30 02:25:18 -0700216 /* Filters an input event.
217 * Return true to dispatch the event unmodified, false to consume the event.
218 * A filter can also transform and inject events later by passing POLICY_FLAG_FILTERED
219 * to injectInputEvent.
220 */
221 virtual bool filterInputEvent(const InputEvent* inputEvent, uint32_t policyFlags) = 0;
222
Jeff Brownb6997262010-10-08 22:31:17 -0700223 /* Intercepts a key event immediately before queueing it.
224 * The policy can use this method as an opportunity to perform power management functions
225 * and early event preprocessing such as updating policy flags.
226 *
227 * This method is expected to set the POLICY_FLAG_PASS_TO_USER policy flag if the event
228 * should be dispatched to applications.
229 */
Jeff Brown1f245102010-11-18 20:53:46 -0800230 virtual void interceptKeyBeforeQueueing(const KeyEvent* keyEvent, uint32_t& policyFlags) = 0;
Jeff Brownb6997262010-10-08 22:31:17 -0700231
Jeff Brown56194eb2011-03-02 19:23:13 -0800232 /* Intercepts a touch, trackball or other motion event before queueing it.
Jeff Brownb6997262010-10-08 22:31:17 -0700233 * The policy can use this method as an opportunity to perform power management functions
234 * and early event preprocessing such as updating policy flags.
235 *
236 * This method is expected to set the POLICY_FLAG_PASS_TO_USER policy flag if the event
237 * should be dispatched to applications.
238 */
Jeff Brown56194eb2011-03-02 19:23:13 -0800239 virtual void interceptMotionBeforeQueueing(nsecs_t when, uint32_t& policyFlags) = 0;
Jeff Brownb6997262010-10-08 22:31:17 -0700240
Jeff Brownb88102f2010-09-08 11:49:43 -0700241 /* Allows the policy a chance to intercept a key before dispatching. */
Jeff Brown905805a2011-10-12 13:57:59 -0700242 virtual nsecs_t interceptKeyBeforeDispatching(const sp<InputWindowHandle>& inputWindowHandle,
Jeff Brownb88102f2010-09-08 11:49:43 -0700243 const KeyEvent* keyEvent, uint32_t policyFlags) = 0;
244
Jeff Brown49ed71d2010-12-06 17:13:33 -0800245 /* Allows the policy a chance to perform default processing for an unhandled key.
246 * Returns an alternate keycode to redispatch as a fallback, or 0 to give up. */
Jeff Brown928e0542011-01-10 11:17:36 -0800247 virtual bool dispatchUnhandledKey(const sp<InputWindowHandle>& inputWindowHandle,
Jeff Brown49ed71d2010-12-06 17:13:33 -0800248 const KeyEvent* keyEvent, uint32_t policyFlags, KeyEvent* outFallbackKeyEvent) = 0;
Jeff Brown3915bb82010-11-05 15:02:16 -0700249
Jeff Brownb6997262010-10-08 22:31:17 -0700250 /* Notifies the policy about switch events.
251 */
252 virtual void notifySwitch(nsecs_t when,
Jeff Brownbcc046a2012-09-27 20:46:43 -0700253 uint32_t switchValues, uint32_t switchMask, uint32_t policyFlags) = 0;
Jeff Brownb6997262010-10-08 22:31:17 -0700254
Jeff Brownb88102f2010-09-08 11:49:43 -0700255 /* Poke user activity for an event dispatched to a window. */
Jeff Brown01ce2e92010-09-26 22:20:12 -0700256 virtual void pokeUserActivity(nsecs_t eventTime, int32_t eventType) = 0;
Jeff Brownb88102f2010-09-08 11:49:43 -0700257
258 /* Checks whether a given application pid/uid has permission to inject input events
259 * into other applications.
260 *
261 * This method is special in that its implementation promises to be non-reentrant and
262 * is safe to call while holding other locks. (Most other methods make no such guarantees!)
263 */
264 virtual bool checkInjectEventsPermissionNonReentrant(
265 int32_t injectorPid, int32_t injectorUid) = 0;
Jeff Brown9c3cda02010-06-15 01:31:58 -0700266};
267
268
Jeff Brown46b9ac02010-04-22 18:58:52 -0700269/* Notifies the system about input events generated by the input reader.
270 * The dispatcher is expected to be mostly asynchronous. */
Jeff Brownbe1aa822011-07-27 16:04:54 -0700271class InputDispatcherInterface : public virtual RefBase, public InputListenerInterface {
Jeff Brown46b9ac02010-04-22 18:58:52 -0700272protected:
273 InputDispatcherInterface() { }
274 virtual ~InputDispatcherInterface() { }
275
276public:
Jeff Brownb88102f2010-09-08 11:49:43 -0700277 /* Dumps the state of the input dispatcher.
278 *
279 * This method may be called on any thread (usually by the input manager). */
280 virtual void dump(String8& dump) = 0;
281
Jeff Brown89ef0722011-08-10 16:25:21 -0700282 /* Called by the heatbeat to ensures that the dispatcher has not deadlocked. */
283 virtual void monitor() = 0;
284
Jeff Brown46b9ac02010-04-22 18:58:52 -0700285 /* Runs a single iteration of the dispatch loop.
286 * Nominally processes one queued event, a timeout, or a response from an input consumer.
287 *
288 * This method should only be called on the input dispatcher thread.
289 */
290 virtual void dispatchOnce() = 0;
291
Jeff Brown7fbdc842010-06-17 20:52:56 -0700292 /* Injects an input event and optionally waits for sync.
Jeff Brown6ec402b2010-07-28 15:48:59 -0700293 * The synchronization mode determines whether the method blocks while waiting for
294 * input injection to proceed.
Jeff Brown7fbdc842010-06-17 20:52:56 -0700295 * Returns one of the INPUT_EVENT_INJECTION_XXX constants.
296 *
297 * This method may be called on any thread (usually by the input manager).
298 */
299 virtual int32_t injectInputEvent(const InputEvent* event,
Jeff Brown0029c662011-03-30 02:25:18 -0700300 int32_t injectorPid, int32_t injectorUid, int32_t syncMode, int32_t timeoutMillis,
301 uint32_t policyFlags) = 0;
Jeff Brown7fbdc842010-06-17 20:52:56 -0700302
Jeff Brownb88102f2010-09-08 11:49:43 -0700303 /* Sets the list of input windows.
304 *
305 * This method may be called on any thread (usually by the input manager).
306 */
Jeff Brown9302c872011-07-13 22:51:29 -0700307 virtual void setInputWindows(const Vector<sp<InputWindowHandle> >& inputWindowHandles) = 0;
Jeff Brownb88102f2010-09-08 11:49:43 -0700308
309 /* Sets the focused application.
310 *
311 * This method may be called on any thread (usually by the input manager).
312 */
Jeff Brown9302c872011-07-13 22:51:29 -0700313 virtual void setFocusedApplication(
314 const sp<InputApplicationHandle>& inputApplicationHandle) = 0;
Jeff Brownb88102f2010-09-08 11:49:43 -0700315
316 /* Sets the input dispatching mode.
317 *
318 * This method may be called on any thread (usually by the input manager).
319 */
320 virtual void setInputDispatchMode(bool enabled, bool frozen) = 0;
321
Jeff Brown0029c662011-03-30 02:25:18 -0700322 /* Sets whether input event filtering is enabled.
323 * When enabled, incoming input events are sent to the policy's filterInputEvent
324 * method instead of being dispatched. The filter is expected to use
325 * injectInputEvent to inject the events it would like to have dispatched.
326 * It should include POLICY_FLAG_FILTERED in the policy flags during injection.
327 */
328 virtual void setInputFilterEnabled(bool enabled) = 0;
329
Jeff Browne6504122010-09-27 14:52:15 -0700330 /* Transfers touch focus from the window associated with one channel to the
331 * window associated with the other channel.
332 *
333 * Returns true on success. False if the window did not actually have touch focus.
334 */
335 virtual bool transferTouchFocus(const sp<InputChannel>& fromChannel,
336 const sp<InputChannel>& toChannel) = 0;
337
Jeff Brown46b9ac02010-04-22 18:58:52 -0700338 /* Registers or unregister input channels that may be used as targets for input events.
Jeff Brownb88102f2010-09-08 11:49:43 -0700339 * If monitor is true, the channel will receive a copy of all input events.
Jeff Brown46b9ac02010-04-22 18:58:52 -0700340 *
341 * These methods may be called on any thread (usually by the input manager).
342 */
Jeff Brown928e0542011-01-10 11:17:36 -0800343 virtual status_t registerInputChannel(const sp<InputChannel>& inputChannel,
344 const sp<InputWindowHandle>& inputWindowHandle, bool monitor) = 0;
Jeff Brown46b9ac02010-04-22 18:58:52 -0700345 virtual status_t unregisterInputChannel(const sp<InputChannel>& inputChannel) = 0;
346};
347
Jeff Brown9c3cda02010-06-15 01:31:58 -0700348/* Dispatches events to input targets. Some functions of the input dispatcher, such as
349 * identifying input targets, are controlled by a separate policy object.
350 *
351 * IMPORTANT INVARIANT:
352 * Because the policy can potentially block or cause re-entrance into the input dispatcher,
353 * the input dispatcher never calls into the policy while holding its internal locks.
354 * The implementation is also carefully designed to recover from scenarios such as an
355 * input channel becoming unregistered while identifying input targets or processing timeouts.
356 *
357 * Methods marked 'Locked' must be called with the lock acquired.
358 *
359 * Methods marked 'LockedInterruptible' must be called with the lock acquired but
360 * may during the course of their execution release the lock, call into the policy, and
361 * then reacquire the lock. The caller is responsible for recovering gracefully.
362 *
363 * A 'LockedInterruptible' method may called a 'Locked' method, but NOT vice-versa.
364 */
Jeff Brown46b9ac02010-04-22 18:58:52 -0700365class InputDispatcher : public InputDispatcherInterface {
366protected:
367 virtual ~InputDispatcher();
368
369public:
Jeff Brown9c3cda02010-06-15 01:31:58 -0700370 explicit InputDispatcher(const sp<InputDispatcherPolicyInterface>& policy);
Jeff Brown46b9ac02010-04-22 18:58:52 -0700371
Jeff Brownb88102f2010-09-08 11:49:43 -0700372 virtual void dump(String8& dump);
Jeff Brown89ef0722011-08-10 16:25:21 -0700373 virtual void monitor();
Jeff Brownb88102f2010-09-08 11:49:43 -0700374
Jeff Brown46b9ac02010-04-22 18:58:52 -0700375 virtual void dispatchOnce();
376
Jeff Brownbe1aa822011-07-27 16:04:54 -0700377 virtual void notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args);
378 virtual void notifyKey(const NotifyKeyArgs* args);
379 virtual void notifyMotion(const NotifyMotionArgs* args);
380 virtual void notifySwitch(const NotifySwitchArgs* args);
Jeff Brown65fd2512011-08-18 11:20:58 -0700381 virtual void notifyDeviceReset(const NotifyDeviceResetArgs* args);
Jeff Brown46b9ac02010-04-22 18:58:52 -0700382
Jeff Brown7fbdc842010-06-17 20:52:56 -0700383 virtual int32_t injectInputEvent(const InputEvent* event,
Jeff Brown0029c662011-03-30 02:25:18 -0700384 int32_t injectorPid, int32_t injectorUid, int32_t syncMode, int32_t timeoutMillis,
385 uint32_t policyFlags);
Jeff Brown7fbdc842010-06-17 20:52:56 -0700386
Jeff Brown9302c872011-07-13 22:51:29 -0700387 virtual void setInputWindows(const Vector<sp<InputWindowHandle> >& inputWindowHandles);
388 virtual void setFocusedApplication(const sp<InputApplicationHandle>& inputApplicationHandle);
Jeff Brownb88102f2010-09-08 11:49:43 -0700389 virtual void setInputDispatchMode(bool enabled, bool frozen);
Jeff Brown0029c662011-03-30 02:25:18 -0700390 virtual void setInputFilterEnabled(bool enabled);
Jeff Brown349703e2010-06-22 01:27:15 -0700391
Jeff Browne6504122010-09-27 14:52:15 -0700392 virtual bool transferTouchFocus(const sp<InputChannel>& fromChannel,
393 const sp<InputChannel>& toChannel);
394
Jeff Brown928e0542011-01-10 11:17:36 -0800395 virtual status_t registerInputChannel(const sp<InputChannel>& inputChannel,
396 const sp<InputWindowHandle>& inputWindowHandle, bool monitor);
Jeff Brown46b9ac02010-04-22 18:58:52 -0700397 virtual status_t unregisterInputChannel(const sp<InputChannel>& inputChannel);
398
399private:
400 template <typename T>
401 struct Link {
402 T* next;
403 T* prev;
Jeff Brown3241b6b2012-02-03 15:08:02 -0800404
405 protected:
406 inline Link() : next(NULL), prev(NULL) { }
Jeff Brown46b9ac02010-04-22 18:58:52 -0700407 };
408
Jeff Brown01ce2e92010-09-26 22:20:12 -0700409 struct InjectionState {
410 mutable int32_t refCount;
411
412 int32_t injectorPid;
413 int32_t injectorUid;
414 int32_t injectionResult; // initially INPUT_EVENT_INJECTION_PENDING
415 bool injectionIsAsync; // set to true if injection is not waiting for the result
416 int32_t pendingForegroundDispatches; // the number of foreground dispatches in progress
Jeff Brownac386072011-07-20 15:19:50 -0700417
418 InjectionState(int32_t injectorPid, int32_t injectorUid);
419 void release();
420
421 private:
422 ~InjectionState();
Jeff Brown01ce2e92010-09-26 22:20:12 -0700423 };
424
Jeff Brown46b9ac02010-04-22 18:58:52 -0700425 struct EventEntry : Link<EventEntry> {
426 enum {
Jeff Brown46b9ac02010-04-22 18:58:52 -0700427 TYPE_CONFIGURATION_CHANGED,
Jeff Brown65fd2512011-08-18 11:20:58 -0700428 TYPE_DEVICE_RESET,
Jeff Brown46b9ac02010-04-22 18:58:52 -0700429 TYPE_KEY,
430 TYPE_MOTION
431 };
432
Jeff Brown01ce2e92010-09-26 22:20:12 -0700433 mutable int32_t refCount;
Jeff Brown46b9ac02010-04-22 18:58:52 -0700434 int32_t type;
435 nsecs_t eventTime;
Jeff Brownb6997262010-10-08 22:31:17 -0700436 uint32_t policyFlags;
Jeff Brown01ce2e92010-09-26 22:20:12 -0700437 InjectionState* injectionState;
Jeff Brown7fbdc842010-06-17 20:52:56 -0700438
Jeff Brown9c3cda02010-06-15 01:31:58 -0700439 bool dispatchInProgress; // initially false, set to true while dispatching
Jeff Brown7fbdc842010-06-17 20:52:56 -0700440
Jeff Brown4e91a182011-04-07 11:38:09 -0700441 inline bool isInjected() const { return injectionState != NULL; }
Jeff Brownac386072011-07-20 15:19:50 -0700442
443 void release();
444
Jeff Brown265f1cc2012-06-11 18:01:06 -0700445 virtual void appendDescription(String8& msg) const = 0;
446
Jeff Brownac386072011-07-20 15:19:50 -0700447 protected:
448 EventEntry(int32_t type, nsecs_t eventTime, uint32_t policyFlags);
449 virtual ~EventEntry();
450 void releaseInjectionState();
Jeff Brown46b9ac02010-04-22 18:58:52 -0700451 };
452
453 struct ConfigurationChangedEntry : EventEntry {
Jeff Brownac386072011-07-20 15:19:50 -0700454 ConfigurationChangedEntry(nsecs_t eventTime);
Jeff Brown265f1cc2012-06-11 18:01:06 -0700455 virtual void appendDescription(String8& msg) const;
Jeff Brownac386072011-07-20 15:19:50 -0700456
457 protected:
458 virtual ~ConfigurationChangedEntry();
Jeff Brown46b9ac02010-04-22 18:58:52 -0700459 };
460
Jeff Brown65fd2512011-08-18 11:20:58 -0700461 struct DeviceResetEntry : EventEntry {
462 int32_t deviceId;
463
464 DeviceResetEntry(nsecs_t eventTime, int32_t deviceId);
Jeff Brown265f1cc2012-06-11 18:01:06 -0700465 virtual void appendDescription(String8& msg) const;
Jeff Brown65fd2512011-08-18 11:20:58 -0700466
467 protected:
468 virtual ~DeviceResetEntry();
469 };
470
Jeff Brown46b9ac02010-04-22 18:58:52 -0700471 struct KeyEntry : EventEntry {
472 int32_t deviceId;
Jeff Brown58a2da82011-01-25 16:02:22 -0800473 uint32_t source;
Jeff Brown46b9ac02010-04-22 18:58:52 -0700474 int32_t action;
475 int32_t flags;
476 int32_t keyCode;
477 int32_t scanCode;
478 int32_t metaState;
479 int32_t repeatCount;
480 nsecs_t downTime;
Jeff Brownb88102f2010-09-08 11:49:43 -0700481
482 bool syntheticRepeat; // set to true for synthetic key repeats
483
484 enum InterceptKeyResult {
485 INTERCEPT_KEY_RESULT_UNKNOWN,
486 INTERCEPT_KEY_RESULT_SKIP,
487 INTERCEPT_KEY_RESULT_CONTINUE,
Jeff Brown905805a2011-10-12 13:57:59 -0700488 INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER,
Jeff Brownb88102f2010-09-08 11:49:43 -0700489 };
490 InterceptKeyResult interceptKeyResult; // set based on the interception result
Jeff Brown905805a2011-10-12 13:57:59 -0700491 nsecs_t interceptKeyWakeupTime; // used with INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER
Jeff Brownac386072011-07-20 15:19:50 -0700492
493 KeyEntry(nsecs_t eventTime,
494 int32_t deviceId, uint32_t source, uint32_t policyFlags, int32_t action,
495 int32_t flags, int32_t keyCode, int32_t scanCode, int32_t metaState,
496 int32_t repeatCount, nsecs_t downTime);
Jeff Brown265f1cc2012-06-11 18:01:06 -0700497 virtual void appendDescription(String8& msg) const;
Jeff Brownac386072011-07-20 15:19:50 -0700498 void recycle();
499
500 protected:
501 virtual ~KeyEntry();
Jeff Brown46b9ac02010-04-22 18:58:52 -0700502 };
503
Jeff Brown46b9ac02010-04-22 18:58:52 -0700504 struct MotionEntry : EventEntry {
Jeff Brown3241b6b2012-02-03 15:08:02 -0800505 nsecs_t eventTime;
Jeff Brown46b9ac02010-04-22 18:58:52 -0700506 int32_t deviceId;
Jeff Brown58a2da82011-01-25 16:02:22 -0800507 uint32_t source;
Jeff Brown46b9ac02010-04-22 18:58:52 -0700508 int32_t action;
Jeff Brown85a31762010-09-01 17:01:00 -0700509 int32_t flags;
Jeff Brown46b9ac02010-04-22 18:58:52 -0700510 int32_t metaState;
Jeff Brownfe9f8ab2011-05-06 18:20:01 -0700511 int32_t buttonState;
Jeff Brown46b9ac02010-04-22 18:58:52 -0700512 int32_t edgeFlags;
513 float xPrecision;
514 float yPrecision;
515 nsecs_t downTime;
Jeff Brown83d616a2012-09-09 20:33:43 -0700516 int32_t displayId;
Jeff Brown46b9ac02010-04-22 18:58:52 -0700517 uint32_t pointerCount;
Jeff Brownfe9f8ab2011-05-06 18:20:01 -0700518 PointerProperties pointerProperties[MAX_POINTERS];
Jeff Brown3241b6b2012-02-03 15:08:02 -0800519 PointerCoords pointerCoords[MAX_POINTERS];
Jeff Brownae9fc032010-08-18 15:51:08 -0700520
Jeff Brownac386072011-07-20 15:19:50 -0700521 MotionEntry(nsecs_t eventTime,
Jeff Brown83d616a2012-09-09 20:33:43 -0700522 int32_t deviceId, uint32_t source, uint32_t policyFlags,
523 int32_t action, int32_t flags,
524 int32_t metaState, int32_t buttonState, int32_t edgeFlags,
Jeff Brownac386072011-07-20 15:19:50 -0700525 float xPrecision, float yPrecision,
Jeff Brown83d616a2012-09-09 20:33:43 -0700526 nsecs_t downTime, int32_t displayId, uint32_t pointerCount,
Jeff Brownac386072011-07-20 15:19:50 -0700527 const PointerProperties* pointerProperties, const PointerCoords* pointerCoords);
Jeff Brown265f1cc2012-06-11 18:01:06 -0700528 virtual void appendDescription(String8& msg) const;
Jeff Brownac386072011-07-20 15:19:50 -0700529
Jeff Brownac386072011-07-20 15:19:50 -0700530 protected:
531 virtual ~MotionEntry();
Jeff Brown46b9ac02010-04-22 18:58:52 -0700532 };
533
Jeff Brown9c3cda02010-06-15 01:31:58 -0700534 // Tracks the progress of dispatching a particular event to a particular connection.
Jeff Brown46b9ac02010-04-22 18:58:52 -0700535 struct DispatchEntry : Link<DispatchEntry> {
Jeff Brown072ec962012-02-07 14:46:57 -0800536 const uint32_t seq; // unique sequence number, never 0
537
Jeff Brown46b9ac02010-04-22 18:58:52 -0700538 EventEntry* eventEntry; // the event to dispatch
539 int32_t targetFlags;
540 float xOffset;
541 float yOffset;
Dianne Hackborne2515ee2011-04-27 18:52:56 -0400542 float scaleFactor;
Jeff Brown265f1cc2012-06-11 18:01:06 -0700543 nsecs_t deliveryTime; // time when the event was actually delivered
Jeff Brown46b9ac02010-04-22 18:58:52 -0700544
Jeff Brown81346812011-06-28 20:08:48 -0700545 // Set to the resolved action and flags when the event is enqueued.
546 int32_t resolvedAction;
547 int32_t resolvedFlags;
548
Jeff Brownac386072011-07-20 15:19:50 -0700549 DispatchEntry(EventEntry* eventEntry,
550 int32_t targetFlags, float xOffset, float yOffset, float scaleFactor);
551 ~DispatchEntry();
552
Jeff Brown519e0242010-09-15 15:18:56 -0700553 inline bool hasForegroundTarget() const {
554 return targetFlags & InputTarget::FLAG_FOREGROUND;
Jeff Brownb88102f2010-09-08 11:49:43 -0700555 }
Jeff Brown01ce2e92010-09-26 22:20:12 -0700556
557 inline bool isSplit() const {
558 return targetFlags & InputTarget::FLAG_SPLIT;
559 }
Jeff Brown072ec962012-02-07 14:46:57 -0800560
561 private:
562 static volatile int32_t sNextSeqAtomic;
563
564 static uint32_t nextSeq();
Jeff Brown46b9ac02010-04-22 18:58:52 -0700565 };
566
Jeff Brown9c3cda02010-06-15 01:31:58 -0700567 // A command entry captures state and behavior for an action to be performed in the
568 // dispatch loop after the initial processing has taken place. It is essentially
569 // a kind of continuation used to postpone sensitive policy interactions to a point
570 // in the dispatch loop where it is safe to release the lock (generally after finishing
571 // the critical parts of the dispatch cycle).
572 //
573 // The special thing about commands is that they can voluntarily release and reacquire
574 // the dispatcher lock at will. Initially when the command starts running, the
575 // dispatcher lock is held. However, if the command needs to call into the policy to
576 // do some work, it can release the lock, do the work, then reacquire the lock again
577 // before returning.
578 //
579 // This mechanism is a bit clunky but it helps to preserve the invariant that the dispatch
580 // never calls into the policy while holding its lock.
581 //
582 // Commands are implicitly 'LockedInterruptible'.
583 struct CommandEntry;
584 typedef void (InputDispatcher::*Command)(CommandEntry* commandEntry);
585
Jeff Brown7fbdc842010-06-17 20:52:56 -0700586 class Connection;
Jeff Brown9c3cda02010-06-15 01:31:58 -0700587 struct CommandEntry : Link<CommandEntry> {
Jeff Brownac386072011-07-20 15:19:50 -0700588 CommandEntry(Command command);
Jeff Brown9c3cda02010-06-15 01:31:58 -0700589 ~CommandEntry();
590
591 Command command;
592
593 // parameters for the command (usage varies by command)
Jeff Brown7fbdc842010-06-17 20:52:56 -0700594 sp<Connection> connection;
Jeff Brownb88102f2010-09-08 11:49:43 -0700595 nsecs_t eventTime;
596 KeyEntry* keyEntry;
Jeff Brownb88102f2010-09-08 11:49:43 -0700597 sp<InputApplicationHandle> inputApplicationHandle;
Jeff Brown928e0542011-01-10 11:17:36 -0800598 sp<InputWindowHandle> inputWindowHandle;
Jeff Brownb88102f2010-09-08 11:49:43 -0700599 int32_t userActivityEventType;
Jeff Brown072ec962012-02-07 14:46:57 -0800600 uint32_t seq;
Jeff Brown3915bb82010-11-05 15:02:16 -0700601 bool handled;
Jeff Brown9c3cda02010-06-15 01:31:58 -0700602 };
603
604 // Generic queue implementation.
Jeff Brown46b9ac02010-04-22 18:58:52 -0700605 template <typename T>
606 struct Queue {
Jeff Brownac386072011-07-20 15:19:50 -0700607 T* head;
608 T* tail;
Jeff Brown46b9ac02010-04-22 18:58:52 -0700609
Jeff Brownac386072011-07-20 15:19:50 -0700610 inline Queue() : head(NULL), tail(NULL) {
Jeff Brown46b9ac02010-04-22 18:58:52 -0700611 }
612
Jeff Brownb88102f2010-09-08 11:49:43 -0700613 inline bool isEmpty() const {
Jeff Brownac386072011-07-20 15:19:50 -0700614 return !head;
Jeff Brown46b9ac02010-04-22 18:58:52 -0700615 }
616
617 inline void enqueueAtTail(T* entry) {
Jeff Brownac386072011-07-20 15:19:50 -0700618 entry->prev = tail;
619 if (tail) {
620 tail->next = entry;
621 } else {
622 head = entry;
623 }
624 entry->next = NULL;
625 tail = entry;
Jeff Brown46b9ac02010-04-22 18:58:52 -0700626 }
627
628 inline void enqueueAtHead(T* entry) {
Jeff Brownac386072011-07-20 15:19:50 -0700629 entry->next = head;
630 if (head) {
631 head->prev = entry;
632 } else {
633 tail = entry;
634 }
635 entry->prev = NULL;
636 head = entry;
Jeff Brown46b9ac02010-04-22 18:58:52 -0700637 }
638
639 inline void dequeue(T* entry) {
Jeff Brownac386072011-07-20 15:19:50 -0700640 if (entry->prev) {
641 entry->prev->next = entry->next;
642 } else {
643 head = entry->next;
644 }
645 if (entry->next) {
646 entry->next->prev = entry->prev;
647 } else {
648 tail = entry->prev;
649 }
Jeff Brown46b9ac02010-04-22 18:58:52 -0700650 }
651
652 inline T* dequeueAtHead() {
Jeff Brownac386072011-07-20 15:19:50 -0700653 T* entry = head;
654 head = entry->next;
655 if (head) {
656 head->prev = NULL;
657 } else {
658 tail = NULL;
659 }
660 return entry;
Jeff Brown46b9ac02010-04-22 18:58:52 -0700661 }
Jeff Brown519e0242010-09-15 15:18:56 -0700662
663 uint32_t count() const;
Jeff Brown46b9ac02010-04-22 18:58:52 -0700664 };
665
Jeff Brownda3d5a92011-03-29 15:11:34 -0700666 /* Specifies which events are to be canceled and why. */
667 struct CancelationOptions {
668 enum Mode {
Jeff Brownb6997262010-10-08 22:31:17 -0700669 CANCEL_ALL_EVENTS = 0,
670 CANCEL_POINTER_EVENTS = 1,
671 CANCEL_NON_POINTER_EVENTS = 2,
Jeff Brown49ed71d2010-12-06 17:13:33 -0800672 CANCEL_FALLBACK_EVENTS = 3,
Jeff Brownb6997262010-10-08 22:31:17 -0700673 };
674
Jeff Brownda3d5a92011-03-29 15:11:34 -0700675 // The criterion to use to determine which events should be canceled.
676 Mode mode;
677
678 // Descriptive reason for the cancelation.
679 const char* reason;
680
681 // The specific keycode of the key event to cancel, or -1 to cancel any key event.
682 int32_t keyCode;
683
Jeff Brown65fd2512011-08-18 11:20:58 -0700684 // The specific device id of events to cancel, or -1 to cancel events from any device.
685 int32_t deviceId;
686
Jeff Brownda3d5a92011-03-29 15:11:34 -0700687 CancelationOptions(Mode mode, const char* reason) :
Jeff Brown65fd2512011-08-18 11:20:58 -0700688 mode(mode), reason(reason), keyCode(-1), deviceId(-1) { }
Jeff Brownda3d5a92011-03-29 15:11:34 -0700689 };
690
691 /* Tracks dispatched key and motion event state so that cancelation events can be
692 * synthesized when events are dropped. */
693 class InputState {
694 public:
Jeff Brownb88102f2010-09-08 11:49:43 -0700695 InputState();
696 ~InputState();
697
698 // Returns true if there is no state to be canceled.
699 bool isNeutral() const;
700
Jeff Brown81346812011-06-28 20:08:48 -0700701 // Returns true if the specified source is known to have received a hover enter
702 // motion event.
Jeff Brown83d616a2012-09-09 20:33:43 -0700703 bool isHovering(int32_t deviceId, uint32_t source, int32_t displayId) const;
Jeff Brownb88102f2010-09-08 11:49:43 -0700704
705 // Records tracking information for a key event that has just been published.
Jeff Brown81346812011-06-28 20:08:48 -0700706 // Returns true if the event should be delivered, false if it is inconsistent
707 // and should be skipped.
708 bool trackKey(const KeyEntry* entry, int32_t action, int32_t flags);
Jeff Brownb88102f2010-09-08 11:49:43 -0700709
710 // Records tracking information for a motion event that has just been published.
Jeff Brown81346812011-06-28 20:08:48 -0700711 // Returns true if the event should be delivered, false if it is inconsistent
712 // and should be skipped.
713 bool trackMotion(const MotionEntry* entry, int32_t action, int32_t flags);
Jeff Brownb88102f2010-09-08 11:49:43 -0700714
Jeff Brownb6997262010-10-08 22:31:17 -0700715 // Synthesizes cancelation events for the current state and resets the tracked state.
Jeff Brownac386072011-07-20 15:19:50 -0700716 void synthesizeCancelationEvents(nsecs_t currentTime,
Jeff Brownda3d5a92011-03-29 15:11:34 -0700717 Vector<EventEntry*>& outEvents, const CancelationOptions& options);
Jeff Brownb88102f2010-09-08 11:49:43 -0700718
719 // Clears the current state.
720 void clear();
721
Jeff Brown9c9f1a32010-10-11 18:32:20 -0700722 // Copies pointer-related parts of the input state to another instance.
723 void copyPointerStateTo(InputState& other) const;
724
Jeff Brownda3d5a92011-03-29 15:11:34 -0700725 // Gets the fallback key associated with a keycode.
726 // Returns -1 if none.
727 // Returns AKEYCODE_UNKNOWN if we are only dispatching the unhandled key to the policy.
728 int32_t getFallbackKey(int32_t originalKeyCode);
729
730 // Sets the fallback key for a particular keycode.
731 void setFallbackKey(int32_t originalKeyCode, int32_t fallbackKeyCode);
732
733 // Removes the fallback key for a particular keycode.
734 void removeFallbackKey(int32_t originalKeyCode);
735
736 inline const KeyedVector<int32_t, int32_t>& getFallbackKeys() const {
737 return mFallbackKeys;
738 }
739
Jeff Brownb88102f2010-09-08 11:49:43 -0700740 private:
Jeff Brownb88102f2010-09-08 11:49:43 -0700741 struct KeyMemento {
742 int32_t deviceId;
Jeff Brown58a2da82011-01-25 16:02:22 -0800743 uint32_t source;
Jeff Brownb88102f2010-09-08 11:49:43 -0700744 int32_t keyCode;
745 int32_t scanCode;
Jeff Brownfd23e3e2012-05-09 13:34:28 -0700746 int32_t metaState;
Jeff Brown49ed71d2010-12-06 17:13:33 -0800747 int32_t flags;
Jeff Brownb88102f2010-09-08 11:49:43 -0700748 nsecs_t downTime;
Jeff Brownfd23e3e2012-05-09 13:34:28 -0700749 uint32_t policyFlags;
Jeff Brownb88102f2010-09-08 11:49:43 -0700750 };
751
752 struct MotionMemento {
753 int32_t deviceId;
Jeff Brown58a2da82011-01-25 16:02:22 -0800754 uint32_t source;
Jeff Brown81346812011-06-28 20:08:48 -0700755 int32_t flags;
Jeff Brownb88102f2010-09-08 11:49:43 -0700756 float xPrecision;
757 float yPrecision;
758 nsecs_t downTime;
Jeff Brown83d616a2012-09-09 20:33:43 -0700759 int32_t displayId;
Jeff Brownb88102f2010-09-08 11:49:43 -0700760 uint32_t pointerCount;
Jeff Brownfe9f8ab2011-05-06 18:20:01 -0700761 PointerProperties pointerProperties[MAX_POINTERS];
Jeff Brownb88102f2010-09-08 11:49:43 -0700762 PointerCoords pointerCoords[MAX_POINTERS];
Jeff Browna032cc02011-03-07 16:56:21 -0800763 bool hovering;
Jeff Brownfd23e3e2012-05-09 13:34:28 -0700764 uint32_t policyFlags;
Jeff Brownb88102f2010-09-08 11:49:43 -0700765
766 void setPointers(const MotionEntry* entry);
767 };
768
769 Vector<KeyMemento> mKeyMementos;
770 Vector<MotionMemento> mMotionMementos;
Jeff Brownda3d5a92011-03-29 15:11:34 -0700771 KeyedVector<int32_t, int32_t> mFallbackKeys;
Jeff Brownb6997262010-10-08 22:31:17 -0700772
Jeff Brown81346812011-06-28 20:08:48 -0700773 ssize_t findKeyMemento(const KeyEntry* entry) const;
774 ssize_t findMotionMemento(const MotionEntry* entry, bool hovering) const;
775
776 void addKeyMemento(const KeyEntry* entry, int32_t flags);
777 void addMotionMemento(const MotionEntry* entry, int32_t flags, bool hovering);
778
Jeff Brown49ed71d2010-12-06 17:13:33 -0800779 static bool shouldCancelKey(const KeyMemento& memento,
Jeff Brownda3d5a92011-03-29 15:11:34 -0700780 const CancelationOptions& options);
Jeff Brown49ed71d2010-12-06 17:13:33 -0800781 static bool shouldCancelMotion(const MotionMemento& memento,
Jeff Brownda3d5a92011-03-29 15:11:34 -0700782 const CancelationOptions& options);
Jeff Brownb88102f2010-09-08 11:49:43 -0700783 };
784
Jeff Brown46b9ac02010-04-22 18:58:52 -0700785 /* Manages the dispatch state associated with a single input channel. */
786 class Connection : public RefBase {
787 protected:
788 virtual ~Connection();
789
790 public:
791 enum Status {
792 // Everything is peachy.
793 STATUS_NORMAL,
794 // An unrecoverable communication error has occurred.
795 STATUS_BROKEN,
Jeff Brown46b9ac02010-04-22 18:58:52 -0700796 // The input channel has been unregistered.
797 STATUS_ZOMBIE
798 };
799
800 Status status;
Jeff Brown928e0542011-01-10 11:17:36 -0800801 sp<InputChannel> inputChannel; // never null
802 sp<InputWindowHandle> inputWindowHandle; // may be null
Jeff Browncc4f7db2011-08-30 20:34:48 -0700803 bool monitor;
Jeff Brown46b9ac02010-04-22 18:58:52 -0700804 InputPublisher inputPublisher;
Jeff Brownb88102f2010-09-08 11:49:43 -0700805 InputState inputState;
Jeff Brownd1c48a02012-02-06 19:12:47 -0800806
807 // True if the socket is full and no further events can be published until
808 // the application consumes some of the input.
809 bool inputPublisherBlocked;
810
811 // Queue of events that need to be published to the connection.
Jeff Brown46b9ac02010-04-22 18:58:52 -0700812 Queue<DispatchEntry> outboundQueue;
Jeff Brown46b9ac02010-04-22 18:58:52 -0700813
Jeff Brownd1c48a02012-02-06 19:12:47 -0800814 // Queue of events that have been published to the connection but that have not
815 // yet received a "finished" response from the application.
816 Queue<DispatchEntry> waitQueue;
817
Jeff Brown928e0542011-01-10 11:17:36 -0800818 explicit Connection(const sp<InputChannel>& inputChannel,
Jeff Browncc4f7db2011-08-30 20:34:48 -0700819 const sp<InputWindowHandle>& inputWindowHandle, bool monitor);
Jeff Brown46b9ac02010-04-22 18:58:52 -0700820
Jeff Brown9c3cda02010-06-15 01:31:58 -0700821 inline const char* getInputChannelName() const { return inputChannel->getName().string(); }
822
Jeff Brown481c1572012-03-09 14:41:15 -0800823 const char* getWindowName() const;
Jeff Brown9c3cda02010-06-15 01:31:58 -0700824 const char* getStatusLabel() const;
Jeff Brown072ec962012-02-07 14:46:57 -0800825
826 DispatchEntry* findWaitQueueEntry(uint32_t seq);
Jeff Brown46b9ac02010-04-22 18:58:52 -0700827 };
828
Jeff Brownb6997262010-10-08 22:31:17 -0700829 enum DropReason {
830 DROP_REASON_NOT_DROPPED = 0,
831 DROP_REASON_POLICY = 1,
832 DROP_REASON_APP_SWITCH = 2,
833 DROP_REASON_DISABLED = 3,
Jeff Brown928e0542011-01-10 11:17:36 -0800834 DROP_REASON_BLOCKED = 4,
835 DROP_REASON_STALE = 5,
Jeff Brownb6997262010-10-08 22:31:17 -0700836 };
837
Jeff Brown9c3cda02010-06-15 01:31:58 -0700838 sp<InputDispatcherPolicyInterface> mPolicy;
Jeff Brown214eaf42011-05-26 19:17:02 -0700839 InputDispatcherConfiguration mConfig;
Jeff Brown46b9ac02010-04-22 18:58:52 -0700840
841 Mutex mLock;
842
Jeff Brown112b5f52012-01-27 17:32:06 -0800843 Condition mDispatcherIsAliveCondition;
844
Jeff Brown4fe6c3e2010-09-13 23:17:30 -0700845 sp<Looper> mLooper;
Jeff Brown46b9ac02010-04-22 18:58:52 -0700846
Jeff Brownb88102f2010-09-08 11:49:43 -0700847 EventEntry* mPendingEvent;
Jeff Brown9c3cda02010-06-15 01:31:58 -0700848 Queue<EventEntry> mInboundQueue;
849 Queue<CommandEntry> mCommandQueue;
850
Jeff Brown214eaf42011-05-26 19:17:02 -0700851 void dispatchOnceInnerLocked(nsecs_t* nextWakeupTime);
Jeff Brownb88102f2010-09-08 11:49:43 -0700852
Jeff Brown4fe6c3e2010-09-13 23:17:30 -0700853 // Enqueues an inbound event. Returns true if mLooper->wake() should be called.
Jeff Brownb88102f2010-09-08 11:49:43 -0700854 bool enqueueInboundEventLocked(EventEntry* entry);
855
Jeff Brownb6997262010-10-08 22:31:17 -0700856 // Cleans up input state when dropping an inbound event.
857 void dropInboundEventLocked(EventEntry* entry, DropReason dropReason);
858
Jeff Brownb88102f2010-09-08 11:49:43 -0700859 // App switch latency optimization.
Jeff Brownb6997262010-10-08 22:31:17 -0700860 bool mAppSwitchSawKeyDown;
Jeff Brownb88102f2010-09-08 11:49:43 -0700861 nsecs_t mAppSwitchDueTime;
862
Jeff Brownb6997262010-10-08 22:31:17 -0700863 static bool isAppSwitchKeyCode(int32_t keyCode);
864 bool isAppSwitchKeyEventLocked(KeyEntry* keyEntry);
Jeff Brownb88102f2010-09-08 11:49:43 -0700865 bool isAppSwitchPendingLocked();
Jeff Brownb88102f2010-09-08 11:49:43 -0700866 void resetPendingAppSwitchLocked(bool handled);
867
Jeff Brown928e0542011-01-10 11:17:36 -0800868 // Stale event latency optimization.
869 static bool isStaleEventLocked(nsecs_t currentTime, EventEntry* entry);
870
871 // Blocked event latency optimization. Drops old events when the user intends
872 // to transfer focus to a new application.
873 EventEntry* mNextUnblockedEvent;
874
Jeff Brown83d616a2012-09-09 20:33:43 -0700875 sp<InputWindowHandle> findTouchedWindowAtLocked(int32_t displayId, int32_t x, int32_t y);
Jeff Brown928e0542011-01-10 11:17:36 -0800876
Jeff Browncbee6d62012-02-03 20:11:27 -0800877 // All registered connections mapped by channel file descriptor.
878 KeyedVector<int, sp<Connection> > mConnectionsByFd;
Jeff Brown46b9ac02010-04-22 18:58:52 -0700879
Jeff Brown519e0242010-09-15 15:18:56 -0700880 ssize_t getConnectionIndexLocked(const sp<InputChannel>& inputChannel);
Jeff Brown2cbecea2010-08-17 15:59:26 -0700881
Jeff Brownb88102f2010-09-08 11:49:43 -0700882 // Input channels that will receive a copy of all input events.
883 Vector<sp<InputChannel> > mMonitoringChannels;
Jeff Brown46b9ac02010-04-22 18:58:52 -0700884
Jeff Brown7fbdc842010-06-17 20:52:56 -0700885 // Event injection and synchronization.
886 Condition mInjectionResultAvailableCondition;
Jeff Brownb6997262010-10-08 22:31:17 -0700887 bool hasInjectionPermission(int32_t injectorPid, int32_t injectorUid);
Jeff Brown7fbdc842010-06-17 20:52:56 -0700888 void setInjectionResultLocked(EventEntry* entry, int32_t injectionResult);
889
Jeff Brown6ec402b2010-07-28 15:48:59 -0700890 Condition mInjectionSyncFinishedCondition;
Jeff Brown01ce2e92010-09-26 22:20:12 -0700891 void incrementPendingForegroundDispatchesLocked(EventEntry* entry);
Jeff Brown519e0242010-09-15 15:18:56 -0700892 void decrementPendingForegroundDispatchesLocked(EventEntry* entry);
Jeff Brown6ec402b2010-07-28 15:48:59 -0700893
Jeff Brown46b9ac02010-04-22 18:58:52 -0700894 // Key repeat tracking.
Jeff Brown46b9ac02010-04-22 18:58:52 -0700895 struct KeyRepeatState {
896 KeyEntry* lastKeyEntry; // or null if no repeat
897 nsecs_t nextRepeatTime;
898 } mKeyRepeatState;
899
900 void resetKeyRepeatLocked();
Jeff Brown214eaf42011-05-26 19:17:02 -0700901 KeyEntry* synthesizeKeyRepeatLocked(nsecs_t currentTime);
Jeff Brown46b9ac02010-04-22 18:58:52 -0700902
Jeff Brown9c3cda02010-06-15 01:31:58 -0700903 // Deferred command processing.
Jeff Brown074b8b72012-10-31 19:01:31 -0700904 bool haveCommandsLocked() const;
Jeff Brown9c3cda02010-06-15 01:31:58 -0700905 bool runCommandsLockedInterruptible();
906 CommandEntry* postCommandLocked(Command command);
907
Jeff Brown83d616a2012-09-09 20:33:43 -0700908 // Input filter processing.
909 bool shouldSendKeyToInputFilterLocked(const NotifyKeyArgs* args);
910 bool shouldSendMotionToInputFilterLocked(const NotifyMotionArgs* args);
911
Jeff Brownb88102f2010-09-08 11:49:43 -0700912 // Inbound event processing.
913 void drainInboundQueueLocked();
Jeff Brown54a18252010-09-16 14:07:33 -0700914 void releasePendingEventLocked();
915 void releaseInboundEventLocked(EventEntry* entry);
Jeff Brown46b9ac02010-04-22 18:58:52 -0700916
Jeff Brownb88102f2010-09-08 11:49:43 -0700917 // Dispatch state.
918 bool mDispatchEnabled;
919 bool mDispatchFrozen;
Jeff Brown0029c662011-03-30 02:25:18 -0700920 bool mInputFilterEnabled;
Jeff Brown01ce2e92010-09-26 22:20:12 -0700921
Jeff Brown9302c872011-07-13 22:51:29 -0700922 Vector<sp<InputWindowHandle> > mWindowHandles;
Jeff Brown01ce2e92010-09-26 22:20:12 -0700923
Jeff Brown9302c872011-07-13 22:51:29 -0700924 sp<InputWindowHandle> getWindowHandleLocked(const sp<InputChannel>& inputChannel) const;
925 bool hasWindowHandleLocked(const sp<InputWindowHandle>& windowHandle) const;
Jeff Brownb88102f2010-09-08 11:49:43 -0700926
927 // Focus tracking for keys, trackball, etc.
Jeff Brown9302c872011-07-13 22:51:29 -0700928 sp<InputWindowHandle> mFocusedWindowHandle;
Jeff Brownb88102f2010-09-08 11:49:43 -0700929
930 // Focus tracking for touch.
Jeff Brown01ce2e92010-09-26 22:20:12 -0700931 struct TouchedWindow {
Jeff Brown9302c872011-07-13 22:51:29 -0700932 sp<InputWindowHandle> windowHandle;
Jeff Brown01ce2e92010-09-26 22:20:12 -0700933 int32_t targetFlags;
Jeff Brown46e75292010-11-10 16:53:45 -0800934 BitSet32 pointerIds; // zero unless target flag FLAG_SPLIT is set
Jeff Brownb88102f2010-09-08 11:49:43 -0700935 };
Jeff Brown01ce2e92010-09-26 22:20:12 -0700936 struct TouchState {
937 bool down;
938 bool split;
Jeff Brown95712852011-01-04 19:41:59 -0800939 int32_t deviceId; // id of the device that is currently down, others are rejected
Jeff Brown58a2da82011-01-25 16:02:22 -0800940 uint32_t source; // source of the device that is current down, others are rejected
Jeff Brown83d616a2012-09-09 20:33:43 -0700941 int32_t displayId; // id to the display that currently has a touch, others are rejected
Jeff Brown01ce2e92010-09-26 22:20:12 -0700942 Vector<TouchedWindow> windows;
943
944 TouchState();
945 ~TouchState();
946 void reset();
947 void copyFrom(const TouchState& other);
Jeff Brown9302c872011-07-13 22:51:29 -0700948 void addOrUpdateWindow(const sp<InputWindowHandle>& windowHandle,
949 int32_t targetFlags, BitSet32 pointerIds);
Jeff Brownf44e3942012-04-20 11:33:27 -0700950 void removeWindow(const sp<InputWindowHandle>& windowHandle);
Jeff Browna032cc02011-03-07 16:56:21 -0800951 void filterNonAsIsTouchWindows();
Jeff Brown9302c872011-07-13 22:51:29 -0700952 sp<InputWindowHandle> getFirstForegroundWindowHandle() const;
Jeff Brown98db5fa2011-06-08 15:37:10 -0700953 bool isSlippery() const;
Jeff Brown01ce2e92010-09-26 22:20:12 -0700954 };
955
956 TouchState mTouchState;
957 TouchState mTempTouchState;
Jeff Brownb88102f2010-09-08 11:49:43 -0700958
959 // Focused application.
Jeff Brown9302c872011-07-13 22:51:29 -0700960 sp<InputApplicationHandle> mFocusedApplicationHandle;
Jeff Brownb88102f2010-09-08 11:49:43 -0700961
Jeff Brown22aa5122012-06-17 12:01:06 -0700962 // Dispatcher state at time of last ANR.
963 String8 mLastANRState;
964
Jeff Brownb88102f2010-09-08 11:49:43 -0700965 // Dispatch inbound events.
966 bool dispatchConfigurationChangedLocked(
967 nsecs_t currentTime, ConfigurationChangedEntry* entry);
Jeff Brown65fd2512011-08-18 11:20:58 -0700968 bool dispatchDeviceResetLocked(
969 nsecs_t currentTime, DeviceResetEntry* entry);
Jeff Brownb88102f2010-09-08 11:49:43 -0700970 bool dispatchKeyLocked(
Jeff Brown214eaf42011-05-26 19:17:02 -0700971 nsecs_t currentTime, KeyEntry* entry,
Jeff Browne20c9e02010-10-11 14:20:19 -0700972 DropReason* dropReason, nsecs_t* nextWakeupTime);
Jeff Brownb88102f2010-09-08 11:49:43 -0700973 bool dispatchMotionLocked(
974 nsecs_t currentTime, MotionEntry* entry,
Jeff Browne20c9e02010-10-11 14:20:19 -0700975 DropReason* dropReason, nsecs_t* nextWakeupTime);
Jeff Browne9bb9be2012-02-06 15:47:55 -0800976 void dispatchEventLocked(nsecs_t currentTime, EventEntry* entry,
977 const Vector<InputTarget>& inputTargets);
Jeff Brown46b9ac02010-04-22 18:58:52 -0700978
Jeff Brownb88102f2010-09-08 11:49:43 -0700979 void logOutboundKeyDetailsLocked(const char* prefix, const KeyEntry* entry);
980 void logOutboundMotionDetailsLocked(const char* prefix, const MotionEntry* entry);
981
Jeff Browne9bb9be2012-02-06 15:47:55 -0800982 // Keeping track of ANR timeouts.
Jeff Brownb88102f2010-09-08 11:49:43 -0700983 enum InputTargetWaitCause {
984 INPUT_TARGET_WAIT_CAUSE_NONE,
985 INPUT_TARGET_WAIT_CAUSE_SYSTEM_NOT_READY,
986 INPUT_TARGET_WAIT_CAUSE_APPLICATION_NOT_READY,
987 };
988
989 InputTargetWaitCause mInputTargetWaitCause;
990 nsecs_t mInputTargetWaitStartTime;
991 nsecs_t mInputTargetWaitTimeoutTime;
992 bool mInputTargetWaitTimeoutExpired;
Jeff Brown9302c872011-07-13 22:51:29 -0700993 sp<InputApplicationHandle> mInputTargetWaitApplicationHandle;
Jeff Brownb88102f2010-09-08 11:49:43 -0700994
Jeff Browna032cc02011-03-07 16:56:21 -0800995 // Contains the last window which received a hover event.
Jeff Brown9302c872011-07-13 22:51:29 -0700996 sp<InputWindowHandle> mLastHoverWindowHandle;
Jeff Browna032cc02011-03-07 16:56:21 -0800997
Jeff Brownb88102f2010-09-08 11:49:43 -0700998 // Finding targets for input events.
Jeff Brownb88102f2010-09-08 11:49:43 -0700999 int32_t handleTargetsNotReadyLocked(nsecs_t currentTime, const EventEntry* entry,
Jeff Brown9302c872011-07-13 22:51:29 -07001000 const sp<InputApplicationHandle>& applicationHandle,
1001 const sp<InputWindowHandle>& windowHandle,
Jeff Brown265f1cc2012-06-11 18:01:06 -07001002 nsecs_t* nextWakeupTime, const char* reason);
Jeff Brown519e0242010-09-15 15:18:56 -07001003 void resumeAfterTargetsNotReadyTimeoutLocked(nsecs_t newTimeout,
1004 const sp<InputChannel>& inputChannel);
1005 nsecs_t getTimeSpentWaitingForApplicationLocked(nsecs_t currentTime);
Jeff Brownb88102f2010-09-08 11:49:43 -07001006 void resetANRTimeoutsLocked();
1007
Jeff Brown01ce2e92010-09-26 22:20:12 -07001008 int32_t findFocusedWindowTargetsLocked(nsecs_t currentTime, const EventEntry* entry,
Jeff Browne9bb9be2012-02-06 15:47:55 -08001009 Vector<InputTarget>& inputTargets, nsecs_t* nextWakeupTime);
Jeff Brown01ce2e92010-09-26 22:20:12 -07001010 int32_t findTouchedWindowTargetsLocked(nsecs_t currentTime, const MotionEntry* entry,
Jeff Browne9bb9be2012-02-06 15:47:55 -08001011 Vector<InputTarget>& inputTargets, nsecs_t* nextWakeupTime,
1012 bool* outConflictingPointerActions);
Jeff Brownb88102f2010-09-08 11:49:43 -07001013
Jeff Brown9302c872011-07-13 22:51:29 -07001014 void addWindowTargetLocked(const sp<InputWindowHandle>& windowHandle,
Jeff Browne9bb9be2012-02-06 15:47:55 -08001015 int32_t targetFlags, BitSet32 pointerIds, Vector<InputTarget>& inputTargets);
1016 void addMonitoringTargetsLocked(Vector<InputTarget>& inputTargets);
1017
Jeff Browne2fe69e2010-10-18 13:21:23 -07001018 void pokeUserActivityLocked(const EventEntry* eventEntry);
Jeff Brown9302c872011-07-13 22:51:29 -07001019 bool checkInjectionPermission(const sp<InputWindowHandle>& windowHandle,
1020 const InjectionState* injectionState);
1021 bool isWindowObscuredAtPointLocked(const sp<InputWindowHandle>& windowHandle,
1022 int32_t x, int32_t y) const;
Jeff Brownd1c48a02012-02-06 19:12:47 -08001023 bool isWindowReadyForMoreInputLocked(nsecs_t currentTime,
Jeff Brown0952c302012-02-13 13:48:59 -08001024 const sp<InputWindowHandle>& windowHandle, const EventEntry* eventEntry);
Jeff Brown9302c872011-07-13 22:51:29 -07001025 String8 getApplicationWindowLabelLocked(const sp<InputApplicationHandle>& applicationHandle,
1026 const sp<InputWindowHandle>& windowHandle);
Jeff Brownb88102f2010-09-08 11:49:43 -07001027
Jeff Brown46b9ac02010-04-22 18:58:52 -07001028 // Manage the dispatch cycle for a single connection.
Jeff Brown7fbdc842010-06-17 20:52:56 -07001029 // These methods are deliberately not Interruptible because doing all of the work
1030 // with the mutex held makes it easier to ensure that connection invariants are maintained.
1031 // If needed, the methods post commands to run later once the critical bits are done.
1032 void prepareDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,
Jeff Brown3241b6b2012-02-03 15:08:02 -08001033 EventEntry* eventEntry, const InputTarget* inputTarget);
Jeff Brownc0cb3dc2012-01-12 18:30:12 -08001034 void enqueueDispatchEntriesLocked(nsecs_t currentTime, const sp<Connection>& connection,
Jeff Brown3241b6b2012-02-03 15:08:02 -08001035 EventEntry* eventEntry, const InputTarget* inputTarget);
Jeff Browna032cc02011-03-07 16:56:21 -08001036 void enqueueDispatchEntryLocked(const sp<Connection>& connection,
Jeff Brown3241b6b2012-02-03 15:08:02 -08001037 EventEntry* eventEntry, const InputTarget* inputTarget, int32_t dispatchMode);
Jeff Brown519e0242010-09-15 15:18:56 -07001038 void startDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection);
Jeff Brown3915bb82010-11-05 15:02:16 -07001039 void finishDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,
Jeff Brown072ec962012-02-07 14:46:57 -08001040 uint32_t seq, bool handled);
Jeff Browncc4f7db2011-08-30 20:34:48 -07001041 void abortBrokenDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,
1042 bool notify);
Jeff Brownd1c48a02012-02-06 19:12:47 -08001043 void drainDispatchQueueLocked(Queue<DispatchEntry>* queue);
1044 void releaseDispatchEntryLocked(DispatchEntry* dispatchEntry);
Jeff Browncbee6d62012-02-03 20:11:27 -08001045 static int handleReceiveCallback(int fd, int events, void* data);
Jeff Brown46b9ac02010-04-22 18:58:52 -07001046
Jeff Brownb6997262010-10-08 22:31:17 -07001047 void synthesizeCancelationEventsForAllConnectionsLocked(
Jeff Brownda3d5a92011-03-29 15:11:34 -07001048 const CancelationOptions& options);
Jeff Brownb6997262010-10-08 22:31:17 -07001049 void synthesizeCancelationEventsForInputChannelLocked(const sp<InputChannel>& channel,
Jeff Brownda3d5a92011-03-29 15:11:34 -07001050 const CancelationOptions& options);
Jeff Brownb6997262010-10-08 22:31:17 -07001051 void synthesizeCancelationEventsForConnectionLocked(const sp<Connection>& connection,
Jeff Brownda3d5a92011-03-29 15:11:34 -07001052 const CancelationOptions& options);
Jeff Brownb6997262010-10-08 22:31:17 -07001053
Jeff Brown01ce2e92010-09-26 22:20:12 -07001054 // Splitting motion events across windows.
1055 MotionEntry* splitMotionEvent(const MotionEntry* originalMotionEntry, BitSet32 pointerIds);
1056
Jeff Brown120a4592010-10-27 18:43:51 -07001057 // Reset and drop everything the dispatcher is doing.
1058 void resetAndDropEverythingLocked(const char* reason);
1059
Jeff Brownb88102f2010-09-08 11:49:43 -07001060 // Dump state.
1061 void dumpDispatchStateLocked(String8& dump);
1062 void logDispatchStateLocked();
1063
Jeff Browncc4f7db2011-08-30 20:34:48 -07001064 // Registration.
1065 void removeMonitorChannelLocked(const sp<InputChannel>& inputChannel);
1066 status_t unregisterInputChannelLocked(const sp<InputChannel>& inputChannel, bool notify);
1067
Jeff Brown46b9ac02010-04-22 18:58:52 -07001068 // Add or remove a connection to the mActiveConnections vector.
1069 void activateConnectionLocked(Connection* connection);
1070 void deactivateConnectionLocked(Connection* connection);
1071
1072 // Interesting events that we might like to log or tell the framework about.
Jeff Brown9c3cda02010-06-15 01:31:58 -07001073 void onDispatchCycleFinishedLocked(
Jeff Brown072ec962012-02-07 14:46:57 -08001074 nsecs_t currentTime, const sp<Connection>& connection, uint32_t seq, bool handled);
Jeff Brown9c3cda02010-06-15 01:31:58 -07001075 void onDispatchCycleBrokenLocked(
Jeff Brown7fbdc842010-06-17 20:52:56 -07001076 nsecs_t currentTime, const sp<Connection>& connection);
Jeff Brown519e0242010-09-15 15:18:56 -07001077 void onANRLocked(
Jeff Brown9302c872011-07-13 22:51:29 -07001078 nsecs_t currentTime, const sp<InputApplicationHandle>& applicationHandle,
1079 const sp<InputWindowHandle>& windowHandle,
Jeff Brown265f1cc2012-06-11 18:01:06 -07001080 nsecs_t eventTime, nsecs_t waitStartTime, const char* reason);
Jeff Brown9c3cda02010-06-15 01:31:58 -07001081
Jeff Brown7fbdc842010-06-17 20:52:56 -07001082 // Outbound policy interactions.
Jeff Brownb88102f2010-09-08 11:49:43 -07001083 void doNotifyConfigurationChangedInterruptible(CommandEntry* commandEntry);
Jeff Brown9c3cda02010-06-15 01:31:58 -07001084 void doNotifyInputChannelBrokenLockedInterruptible(CommandEntry* commandEntry);
Jeff Brown519e0242010-09-15 15:18:56 -07001085 void doNotifyANRLockedInterruptible(CommandEntry* commandEntry);
Jeff Brownb88102f2010-09-08 11:49:43 -07001086 void doInterceptKeyBeforeDispatchingLockedInterruptible(CommandEntry* commandEntry);
Jeff Brown3915bb82010-11-05 15:02:16 -07001087 void doDispatchCycleFinishedLockedInterruptible(CommandEntry* commandEntry);
Jeff Brownfe9f8ab2011-05-06 18:20:01 -07001088 bool afterKeyEventLockedInterruptible(const sp<Connection>& connection,
1089 DispatchEntry* dispatchEntry, KeyEntry* keyEntry, bool handled);
1090 bool afterMotionEventLockedInterruptible(const sp<Connection>& connection,
1091 DispatchEntry* dispatchEntry, MotionEntry* motionEntry, bool handled);
Jeff Brownb88102f2010-09-08 11:49:43 -07001092 void doPokeUserActivityLockedInterruptible(CommandEntry* commandEntry);
Jeff Brown3915bb82010-11-05 15:02:16 -07001093 void initializeKeyEvent(KeyEvent* event, const KeyEntry* entry);
Jeff Brown519e0242010-09-15 15:18:56 -07001094
1095 // Statistics gathering.
1096 void updateDispatchStatisticsLocked(nsecs_t currentTime, const EventEntry* entry,
1097 int32_t injectionResult, nsecs_t timeSpentWaitingForApplication);
Jeff Brown481c1572012-03-09 14:41:15 -08001098 void traceInboundQueueLengthLocked();
1099 void traceOutboundQueueLengthLocked(const sp<Connection>& connection);
1100 void traceWaitQueueLengthLocked(const sp<Connection>& connection);
Jeff Brown46b9ac02010-04-22 18:58:52 -07001101};
1102
1103/* Enqueues and dispatches input events, endlessly. */
1104class InputDispatcherThread : public Thread {
1105public:
1106 explicit InputDispatcherThread(const sp<InputDispatcherInterface>& dispatcher);
1107 ~InputDispatcherThread();
1108
1109private:
1110 virtual bool threadLoop();
1111
1112 sp<InputDispatcherInterface> mDispatcher;
1113};
1114
1115} // namespace android
1116
Jeff Brownb88102f2010-09-08 11:49:43 -07001117#endif // _UI_INPUT_DISPATCHER_H