InputDispatcher.h revision 65dbe971b1bcefdaa353662f7bde5ea327544113 
1/*
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>
21#include <input/InputTransport.h>
22#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>
28#include <utils/Looper.h>
29#include <utils/BitSet.h>
30#include <cutils/atomic.h>
31
32#include <stddef.h>
33#include <unistd.h>
34#include <limits.h>
35
36#include "InputWindow.h"
37#include "InputApplication.h"
38#include "InputListener.h"
39
40
41namespace android {
42
43/*
44 * 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
64/*
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
80
81/*
82 * 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 {
89        /* This flag indicates that the event is being delivered to a foreground application. */
90        FLAG_FOREGROUND = 1 << 0,
91
92        /* 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. */
95        FLAG_WINDOW_IS_OBSCURED = 1 << 1,
96
97        /* This flag indicates that a motion event is being split across multiple windows. */
98        FLAG_SPLIT = 1 << 2,
99
100        /* 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
106        /* 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
125        /* 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
135        /* Mask for all dispatch modes. */
136        FLAG_DISPATCH_MASK = FLAG_DISPATCH_AS_IS
137                | FLAG_DISPATCH_AS_OUTSIDE
138                | FLAG_DISPATCH_AS_HOVER_ENTER
139                | FLAG_DISPATCH_AS_HOVER_EXIT
140                | FLAG_DISPATCH_AS_SLIPPERY_EXIT
141                | FLAG_DISPATCH_AS_SLIPPERY_ENTER,
142    };
143
144    // The input channel to be targeted.
145    sp<InputChannel> inputChannel;
146
147    // Flags for the input target.
148    int32_t flags;
149
150    // The x and y offset to add to a MotionEvent as it is delivered.
151    // (ignored for KeyEvents)
152    float xOffset, yOffset;
153
154    // Scaling factor to apply to MotionEvent as it is delivered.
155    // (ignored for KeyEvents)
156    float scaleFactor;
157
158    // The subset of pointer ids to include in motion events dispatched to this input target
159    // if FLAG_SPLIT is set.
160    BitSet32 pointerIds;
161};
162
163
164/*
165 * Input dispatcher configuration.
166 *
167 * Specifies various options that modify the behavior of the input dispatcher.
168 * The values provided here are merely defaults. The actual values will come from ViewConfiguration
169 * and are passed into the dispatcher during initialization.
170 */
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
178    InputDispatcherConfiguration() :
179            keyRepeatTimeout(500 * 1000000LL),
180            keyRepeatDelay(50 * 1000000LL) { }
181};
182
183
184/*
185 * 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
202    /* Notifies the system that an application is not responding.
203     * Returns a new timeout to continue waiting, or 0 to abort dispatch. */
204    virtual nsecs_t notifyANR(const sp<InputApplicationHandle>& inputApplicationHandle,
205            const sp<InputWindowHandle>& inputWindowHandle,
206            const String8& reason) = 0;
207
208    /* Notifies the system that an input channel is unrecoverably broken. */
209    virtual void notifyInputChannelBroken(const sp<InputWindowHandle>& inputWindowHandle) = 0;
210
211    /* Gets the input dispatcher configuration. */
212    virtual void getDispatcherConfiguration(InputDispatcherConfiguration* outConfig) = 0;
213
214    /* Filters an input event.
215     * Return true to dispatch the event unmodified, false to consume the event.
216     * A filter can also transform and inject events later by passing POLICY_FLAG_FILTERED
217     * to injectInputEvent.
218     */
219    virtual bool filterInputEvent(const InputEvent* inputEvent, uint32_t policyFlags) = 0;
220
221    /* Intercepts a key event immediately before queueing it.
222     * The policy can use this method as an opportunity to perform power management functions
223     * and early event preprocessing such as updating policy flags.
224     *
225     * This method is expected to set the POLICY_FLAG_PASS_TO_USER policy flag if the event
226     * should be dispatched to applications.
227     */
228    virtual void interceptKeyBeforeQueueing(const KeyEvent* keyEvent, uint32_t& policyFlags) = 0;
229
230    /* Intercepts a touch, trackball or other motion event before queueing it.
231     * The policy can use this method as an opportunity to perform power management functions
232     * and early event preprocessing such as updating policy flags.
233     *
234     * This method is expected to set the POLICY_FLAG_PASS_TO_USER policy flag if the event
235     * should be dispatched to applications.
236     */
237    virtual void interceptMotionBeforeQueueing(nsecs_t when, uint32_t& policyFlags) = 0;
238
239    /* Allows the policy a chance to intercept a key before dispatching. */
240    virtual nsecs_t interceptKeyBeforeDispatching(const sp<InputWindowHandle>& inputWindowHandle,
241            const KeyEvent* keyEvent, uint32_t policyFlags) = 0;
242
243    /* Allows the policy a chance to perform default processing for an unhandled key.
244     * Returns an alternate keycode to redispatch as a fallback, or 0 to give up. */
245    virtual bool dispatchUnhandledKey(const sp<InputWindowHandle>& inputWindowHandle,
246            const KeyEvent* keyEvent, uint32_t policyFlags, KeyEvent* outFallbackKeyEvent) = 0;
247
248    /* Notifies the policy about switch events.
249     */
250    virtual void notifySwitch(nsecs_t when,
251            uint32_t switchValues, uint32_t switchMask, uint32_t policyFlags) = 0;
252
253    /* Poke user activity for an event dispatched to a window. */
254    virtual void pokeUserActivity(nsecs_t eventTime, int32_t eventType) = 0;
255
256    /* Checks whether a given application pid/uid has permission to inject input events
257     * into other applications.
258     *
259     * This method is special in that its implementation promises to be non-reentrant and
260     * is safe to call while holding other locks.  (Most other methods make no such guarantees!)
261     */
262    virtual bool checkInjectEventsPermissionNonReentrant(
263            int32_t injectorPid, int32_t injectorUid) = 0;
264};
265
266
267/* Notifies the system about input events generated by the input reader.
268 * The dispatcher is expected to be mostly asynchronous. */
269class InputDispatcherInterface : public virtual RefBase, public InputListenerInterface {
270protected:
271    InputDispatcherInterface() { }
272    virtual ~InputDispatcherInterface() { }
273
274public:
275    /* Dumps the state of the input dispatcher.
276     *
277     * This method may be called on any thread (usually by the input manager). */
278    virtual void dump(String8& dump) = 0;
279
280    /* Called by the heatbeat to ensures that the dispatcher has not deadlocked. */
281    virtual void monitor() = 0;
282
283    /* Runs a single iteration of the dispatch loop.
284     * Nominally processes one queued event, a timeout, or a response from an input consumer.
285     *
286     * This method should only be called on the input dispatcher thread.
287     */
288    virtual void dispatchOnce() = 0;
289
290    /* Injects an input event and optionally waits for sync.
291     * The synchronization mode determines whether the method blocks while waiting for
292     * input injection to proceed.
293     * Returns one of the INPUT_EVENT_INJECTION_XXX constants.
294     *
295     * This method may be called on any thread (usually by the input manager).
296     */
297    virtual int32_t injectInputEvent(const InputEvent* event, int32_t displayId,
298            int32_t injectorPid, int32_t injectorUid, int32_t syncMode, int32_t timeoutMillis,
299            uint32_t policyFlags) = 0;
300
301    /* Sets the list of input windows.
302     *
303     * This method may be called on any thread (usually by the input manager).
304     */
305    virtual void setInputWindows(const Vector<sp<InputWindowHandle> >& inputWindowHandles) = 0;
306
307    /* Sets the focused application.
308     *
309     * This method may be called on any thread (usually by the input manager).
310     */
311    virtual void setFocusedApplication(
312            const sp<InputApplicationHandle>& inputApplicationHandle) = 0;
313
314    /* Sets the input dispatching mode.
315     *
316     * This method may be called on any thread (usually by the input manager).
317     */
318    virtual void setInputDispatchMode(bool enabled, bool frozen) = 0;
319
320    /* Sets whether input event filtering is enabled.
321     * When enabled, incoming input events are sent to the policy's filterInputEvent
322     * method instead of being dispatched.  The filter is expected to use
323     * injectInputEvent to inject the events it would like to have dispatched.
324     * It should include POLICY_FLAG_FILTERED in the policy flags during injection.
325     */
326    virtual void setInputFilterEnabled(bool enabled) = 0;
327
328    /* Transfers touch focus from the window associated with one channel to the
329     * window associated with the other channel.
330     *
331     * Returns true on success.  False if the window did not actually have touch focus.
332     */
333    virtual bool transferTouchFocus(const sp<InputChannel>& fromChannel,
334            const sp<InputChannel>& toChannel) = 0;
335
336    /* Registers or unregister input channels that may be used as targets for input events.
337     * If monitor is true, the channel will receive a copy of all input events.
338     *
339     * These methods may be called on any thread (usually by the input manager).
340     */
341    virtual status_t registerInputChannel(const sp<InputChannel>& inputChannel,
342            const sp<InputWindowHandle>& inputWindowHandle, bool monitor) = 0;
343    virtual status_t unregisterInputChannel(const sp<InputChannel>& inputChannel) = 0;
344};
345
346/* Dispatches events to input targets.  Some functions of the input dispatcher, such as
347 * identifying input targets, are controlled by a separate policy object.
348 *
349 * IMPORTANT INVARIANT:
350 *     Because the policy can potentially block or cause re-entrance into the input dispatcher,
351 *     the input dispatcher never calls into the policy while holding its internal locks.
352 *     The implementation is also carefully designed to recover from scenarios such as an
353 *     input channel becoming unregistered while identifying input targets or processing timeouts.
354 *
355 *     Methods marked 'Locked' must be called with the lock acquired.
356 *
357 *     Methods marked 'LockedInterruptible' must be called with the lock acquired but
358 *     may during the course of their execution release the lock, call into the policy, and
359 *     then reacquire the lock.  The caller is responsible for recovering gracefully.
360 *
361 *     A 'LockedInterruptible' method may called a 'Locked' method, but NOT vice-versa.
362 */
363class InputDispatcher : public InputDispatcherInterface {
364protected:
365    virtual ~InputDispatcher();
366
367public:
368    explicit InputDispatcher(const sp<InputDispatcherPolicyInterface>& policy);
369
370    virtual void dump(String8& dump);
371    virtual void monitor();
372
373    virtual void dispatchOnce();
374
375    virtual void notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args);
376    virtual void notifyKey(const NotifyKeyArgs* args);
377    virtual void notifyMotion(const NotifyMotionArgs* args);
378    virtual void notifySwitch(const NotifySwitchArgs* args);
379    virtual void notifyDeviceReset(const NotifyDeviceResetArgs* args);
380
381    virtual int32_t injectInputEvent(const InputEvent* event, int32_t displayId,
382            int32_t injectorPid, int32_t injectorUid, int32_t syncMode, int32_t timeoutMillis,
383            uint32_t policyFlags);
384
385    virtual void setInputWindows(const Vector<sp<InputWindowHandle> >& inputWindowHandles);
386    virtual void setFocusedApplication(const sp<InputApplicationHandle>& inputApplicationHandle);
387    virtual void setInputDispatchMode(bool enabled, bool frozen);
388    virtual void setInputFilterEnabled(bool enabled);
389
390    virtual bool transferTouchFocus(const sp<InputChannel>& fromChannel,
391            const sp<InputChannel>& toChannel);
392
393    virtual status_t registerInputChannel(const sp<InputChannel>& inputChannel,
394            const sp<InputWindowHandle>& inputWindowHandle, bool monitor);
395    virtual status_t unregisterInputChannel(const sp<InputChannel>& inputChannel);
396
397private:
398    template <typename T>
399    struct Link {
400        T* next;
401        T* prev;
402
403    protected:
404        inline Link() : next(NULL), prev(NULL) { }
405    };
406
407    struct InjectionState {
408        mutable int32_t refCount;
409
410        int32_t injectorPid;
411        int32_t injectorUid;
412        int32_t injectionResult;  // initially INPUT_EVENT_INJECTION_PENDING
413        bool injectionIsAsync; // set to true if injection is not waiting for the result
414        int32_t pendingForegroundDispatches; // the number of foreground dispatches in progress
415
416        InjectionState(int32_t injectorPid, int32_t injectorUid);
417        void release();
418
419    private:
420        ~InjectionState();
421    };
422
423    struct EventEntry : Link<EventEntry> {
424        enum {
425            TYPE_CONFIGURATION_CHANGED,
426            TYPE_DEVICE_RESET,
427            TYPE_KEY,
428            TYPE_MOTION
429        };
430
431        mutable int32_t refCount;
432        int32_t type;
433        nsecs_t eventTime;
434        uint32_t policyFlags;
435        InjectionState* injectionState;
436
437        bool dispatchInProgress; // initially false, set to true while dispatching
438
439        inline bool isInjected() const { return injectionState != NULL; }
440
441        void release();
442
443        virtual void appendDescription(String8& msg) const = 0;
444
445    protected:
446        EventEntry(int32_t type, nsecs_t eventTime, uint32_t policyFlags);
447        virtual ~EventEntry();
448        void releaseInjectionState();
449    };
450
451    struct ConfigurationChangedEntry : EventEntry {
452        ConfigurationChangedEntry(nsecs_t eventTime);
453        virtual void appendDescription(String8& msg) const;
454
455    protected:
456        virtual ~ConfigurationChangedEntry();
457    };
458
459    struct DeviceResetEntry : EventEntry {
460        int32_t deviceId;
461
462        DeviceResetEntry(nsecs_t eventTime, int32_t deviceId);
463        virtual void appendDescription(String8& msg) const;
464
465    protected:
466        virtual ~DeviceResetEntry();
467    };
468
469    struct KeyEntry : EventEntry {
470        int32_t deviceId;
471        uint32_t source;
472        int32_t action;
473        int32_t flags;
474        int32_t keyCode;
475        int32_t scanCode;
476        int32_t metaState;
477        int32_t repeatCount;
478        nsecs_t downTime;
479
480        bool syntheticRepeat; // set to true for synthetic key repeats
481
482        enum InterceptKeyResult {
483            INTERCEPT_KEY_RESULT_UNKNOWN,
484            INTERCEPT_KEY_RESULT_SKIP,
485            INTERCEPT_KEY_RESULT_CONTINUE,
486            INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER,
487        };
488        InterceptKeyResult interceptKeyResult; // set based on the interception result
489        nsecs_t interceptKeyWakeupTime; // used with INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER
490
491        KeyEntry(nsecs_t eventTime,
492                int32_t deviceId, uint32_t source, uint32_t policyFlags, int32_t action,
493                int32_t flags, int32_t keyCode, int32_t scanCode, int32_t metaState,
494                int32_t repeatCount, nsecs_t downTime);
495        virtual void appendDescription(String8& msg) const;
496        void recycle();
497
498    protected:
499        virtual ~KeyEntry();
500    };
501
502    struct MotionEntry : EventEntry {
503        nsecs_t eventTime;
504        int32_t deviceId;
505        uint32_t source;
506        int32_t action;
507        int32_t flags;
508        int32_t metaState;
509        int32_t buttonState;
510        int32_t edgeFlags;
511        float xPrecision;
512        float yPrecision;
513        nsecs_t downTime;
514        int32_t displayId;
515        uint32_t pointerCount;
516        PointerProperties pointerProperties[MAX_POINTERS];
517        PointerCoords pointerCoords[MAX_POINTERS];
518
519        MotionEntry(nsecs_t eventTime,
520                int32_t deviceId, uint32_t source, uint32_t policyFlags,
521                int32_t action, int32_t flags,
522                int32_t metaState, int32_t buttonState, int32_t edgeFlags,
523                float xPrecision, float yPrecision,
524                nsecs_t downTime, int32_t displayId, uint32_t pointerCount,
525                const PointerProperties* pointerProperties, const PointerCoords* pointerCoords,
526                float xOffset, float yOffset);
527        virtual void appendDescription(String8& msg) const;
528
529    protected:
530        virtual ~MotionEntry();
531    };
532
533    // Tracks the progress of dispatching a particular event to a particular connection.
534    struct DispatchEntry : Link<DispatchEntry> {
535        const uint32_t seq; // unique sequence number, never 0
536
537        EventEntry* eventEntry; // the event to dispatch
538        int32_t targetFlags;
539        float xOffset;
540        float yOffset;
541        float scaleFactor;
542        nsecs_t deliveryTime; // time when the event was actually delivered
543
544        // Set to the resolved action and flags when the event is enqueued.
545        int32_t resolvedAction;
546        int32_t resolvedFlags;
547
548        DispatchEntry(EventEntry* eventEntry,
549                int32_t targetFlags, float xOffset, float yOffset, float scaleFactor);
550        ~DispatchEntry();
551
552        inline bool hasForegroundTarget() const {
553            return targetFlags & InputTarget::FLAG_FOREGROUND;
554        }
555
556        inline bool isSplit() const {
557            return targetFlags & InputTarget::FLAG_SPLIT;
558        }
559
560    private:
561        static volatile int32_t sNextSeqAtomic;
562
563        static uint32_t nextSeq();
564    };
565
566    // A command entry captures state and behavior for an action to be performed in the
567    // dispatch loop after the initial processing has taken place.  It is essentially
568    // a kind of continuation used to postpone sensitive policy interactions to a point
569    // in the dispatch loop where it is safe to release the lock (generally after finishing
570    // the critical parts of the dispatch cycle).
571    //
572    // The special thing about commands is that they can voluntarily release and reacquire
573    // the dispatcher lock at will.  Initially when the command starts running, the
574    // dispatcher lock is held.  However, if the command needs to call into the policy to
575    // do some work, it can release the lock, do the work, then reacquire the lock again
576    // before returning.
577    //
578    // This mechanism is a bit clunky but it helps to preserve the invariant that the dispatch
579    // never calls into the policy while holding its lock.
580    //
581    // Commands are implicitly 'LockedInterruptible'.
582    struct CommandEntry;
583    typedef void (InputDispatcher::*Command)(CommandEntry* commandEntry);
584
585    class Connection;
586    struct CommandEntry : Link<CommandEntry> {
587        CommandEntry(Command command);
588        ~CommandEntry();
589
590        Command command;
591
592        // parameters for the command (usage varies by command)
593        sp<Connection> connection;
594        nsecs_t eventTime;
595        KeyEntry* keyEntry;
596        sp<InputApplicationHandle> inputApplicationHandle;
597        sp<InputWindowHandle> inputWindowHandle;
598        String8 reason;
599        int32_t userActivityEventType;
600        uint32_t seq;
601        bool handled;
602    };
603
604    // Generic queue implementation.
605    template <typename T>
606    struct Queue {
607        T* head;
608        T* tail;
609        uint32_t entryCount;
610
611        inline Queue() : head(NULL), tail(NULL), entryCount(0) {
612        }
613
614        inline bool isEmpty() const {
615            return !head;
616        }
617
618        inline void enqueueAtTail(T* entry) {
619            entryCount++;
620            entry->prev = tail;
621            if (tail) {
622                tail->next = entry;
623            } else {
624                head = entry;
625            }
626            entry->next = NULL;
627            tail = entry;
628        }
629
630        inline void enqueueAtHead(T* entry) {
631            entryCount++;
632            entry->next = head;
633            if (head) {
634                head->prev = entry;
635            } else {
636                tail = entry;
637            }
638            entry->prev = NULL;
639            head = entry;
640        }
641
642        inline void dequeue(T* entry) {
643            entryCount--;
644            if (entry->prev) {
645                entry->prev->next = entry->next;
646            } else {
647                head = entry->next;
648            }
649            if (entry->next) {
650                entry->next->prev = entry->prev;
651            } else {
652                tail = entry->prev;
653            }
654        }
655
656        inline T* dequeueAtHead() {
657            entryCount--;
658            T* entry = head;
659            head = entry->next;
660            if (head) {
661                head->prev = NULL;
662            } else {
663                tail = NULL;
664            }
665            return entry;
666        }
667
668        uint32_t count() const {
669            return entryCount;
670        }
671    };
672
673    /* Specifies which events are to be canceled and why. */
674    struct CancelationOptions {
675        enum Mode {
676            CANCEL_ALL_EVENTS = 0,
677            CANCEL_POINTER_EVENTS = 1,
678            CANCEL_NON_POINTER_EVENTS = 2,
679            CANCEL_FALLBACK_EVENTS = 3,
680        };
681
682        // The criterion to use to determine which events should be canceled.
683        Mode mode;
684
685        // Descriptive reason for the cancelation.
686        const char* reason;
687
688        // The specific keycode of the key event to cancel, or -1 to cancel any key event.
689        int32_t keyCode;
690
691        // The specific device id of events to cancel, or -1 to cancel events from any device.
692        int32_t deviceId;
693
694        CancelationOptions(Mode mode, const char* reason) :
695                mode(mode), reason(reason), keyCode(-1), deviceId(-1) { }
696    };
697
698    /* Tracks dispatched key and motion event state so that cancelation events can be
699     * synthesized when events are dropped. */
700    class InputState {
701    public:
702        InputState();
703        ~InputState();
704
705        // Returns true if there is no state to be canceled.
706        bool isNeutral() const;
707
708        // Returns true if the specified source is known to have received a hover enter
709        // motion event.
710        bool isHovering(int32_t deviceId, uint32_t source, int32_t displayId) const;
711
712        // Records tracking information for a key event that has just been published.
713        // Returns true if the event should be delivered, false if it is inconsistent
714        // and should be skipped.
715        bool trackKey(const KeyEntry* entry, int32_t action, int32_t flags);
716
717        // Records tracking information for a motion event that has just been published.
718        // Returns true if the event should be delivered, false if it is inconsistent
719        // and should be skipped.
720        bool trackMotion(const MotionEntry* entry, int32_t action, int32_t flags);
721
722        // Synthesizes cancelation events for the current state and resets the tracked state.
723        void synthesizeCancelationEvents(nsecs_t currentTime,
724                Vector<EventEntry*>& outEvents, const CancelationOptions& options);
725
726        // Clears the current state.
727        void clear();
728
729        // Copies pointer-related parts of the input state to another instance.
730        void copyPointerStateTo(InputState& other) const;
731
732        // Gets the fallback key associated with a keycode.
733        // Returns -1 if none.
734        // Returns AKEYCODE_UNKNOWN if we are only dispatching the unhandled key to the policy.
735        int32_t getFallbackKey(int32_t originalKeyCode);
736
737        // Sets the fallback key for a particular keycode.
738        void setFallbackKey(int32_t originalKeyCode, int32_t fallbackKeyCode);
739
740        // Removes the fallback key for a particular keycode.
741        void removeFallbackKey(int32_t originalKeyCode);
742
743        inline const KeyedVector<int32_t, int32_t>& getFallbackKeys() const {
744            return mFallbackKeys;
745        }
746
747    private:
748        struct KeyMemento {
749            int32_t deviceId;
750            uint32_t source;
751            int32_t keyCode;
752            int32_t scanCode;
753            int32_t metaState;
754            int32_t flags;
755            nsecs_t downTime;
756            uint32_t policyFlags;
757        };
758
759        struct MotionMemento {
760            int32_t deviceId;
761            uint32_t source;
762            int32_t flags;
763            float xPrecision;
764            float yPrecision;
765            nsecs_t downTime;
766            int32_t displayId;
767            uint32_t pointerCount;
768            PointerProperties pointerProperties[MAX_POINTERS];
769            PointerCoords pointerCoords[MAX_POINTERS];
770            bool hovering;
771            uint32_t policyFlags;
772
773            void setPointers(const MotionEntry* entry);
774        };
775
776        Vector<KeyMemento> mKeyMementos;
777        Vector<MotionMemento> mMotionMementos;
778        KeyedVector<int32_t, int32_t> mFallbackKeys;
779
780        ssize_t findKeyMemento(const KeyEntry* entry) const;
781        ssize_t findMotionMemento(const MotionEntry* entry, bool hovering) const;
782
783        void addKeyMemento(const KeyEntry* entry, int32_t flags);
784        void addMotionMemento(const MotionEntry* entry, int32_t flags, bool hovering);
785
786        static bool shouldCancelKey(const KeyMemento& memento,
787                const CancelationOptions& options);
788        static bool shouldCancelMotion(const MotionMemento& memento,
789                const CancelationOptions& options);
790    };
791
792    /* Manages the dispatch state associated with a single input channel. */
793    class Connection : public RefBase {
794    protected:
795        virtual ~Connection();
796
797    public:
798        enum Status {
799            // Everything is peachy.
800            STATUS_NORMAL,
801            // An unrecoverable communication error has occurred.
802            STATUS_BROKEN,
803            // The input channel has been unregistered.
804            STATUS_ZOMBIE
805        };
806
807        Status status;
808        sp<InputChannel> inputChannel; // never null
809        sp<InputWindowHandle> inputWindowHandle; // may be null
810        bool monitor;
811        InputPublisher inputPublisher;
812        InputState inputState;
813
814        // True if the socket is full and no further events can be published until
815        // the application consumes some of the input.
816        bool inputPublisherBlocked;
817
818        // Queue of events that need to be published to the connection.
819        Queue<DispatchEntry> outboundQueue;
820
821        // Queue of events that have been published to the connection but that have not
822        // yet received a "finished" response from the application.
823        Queue<DispatchEntry> waitQueue;
824
825        explicit Connection(const sp<InputChannel>& inputChannel,
826                const sp<InputWindowHandle>& inputWindowHandle, bool monitor);
827
828        inline const char* getInputChannelName() const { return inputChannel->getName().string(); }
829
830        const char* getWindowName() const;
831        const char* getStatusLabel() const;
832
833        DispatchEntry* findWaitQueueEntry(uint32_t seq);
834    };
835
836    enum DropReason {
837        DROP_REASON_NOT_DROPPED = 0,
838        DROP_REASON_POLICY = 1,
839        DROP_REASON_APP_SWITCH = 2,
840        DROP_REASON_DISABLED = 3,
841        DROP_REASON_BLOCKED = 4,
842        DROP_REASON_STALE = 5,
843    };
844
845    sp<InputDispatcherPolicyInterface> mPolicy;
846    InputDispatcherConfiguration mConfig;
847
848    Mutex mLock;
849
850    Condition mDispatcherIsAliveCondition;
851
852    sp<Looper> mLooper;
853
854    EventEntry* mPendingEvent;
855    Queue<EventEntry> mInboundQueue;
856    Queue<EventEntry> mRecentQueue;
857    Queue<CommandEntry> mCommandQueue;
858
859    void dispatchOnceInnerLocked(nsecs_t* nextWakeupTime);
860
861    // Enqueues an inbound event.  Returns true if mLooper->wake() should be called.
862    bool enqueueInboundEventLocked(EventEntry* entry);
863
864    // Cleans up input state when dropping an inbound event.
865    void dropInboundEventLocked(EventEntry* entry, DropReason dropReason);
866
867    // Adds an event to a queue of recent events for debugging purposes.
868    void addRecentEventLocked(EventEntry* entry);
869
870    // App switch latency optimization.
871    bool mAppSwitchSawKeyDown;
872    nsecs_t mAppSwitchDueTime;
873
874    static bool isAppSwitchKeyCode(int32_t keyCode);
875    bool isAppSwitchKeyEventLocked(KeyEntry* keyEntry);
876    bool isAppSwitchPendingLocked();
877    void resetPendingAppSwitchLocked(bool handled);
878
879    // Stale event latency optimization.
880    static bool isStaleEventLocked(nsecs_t currentTime, EventEntry* entry);
881
882    // Blocked event latency optimization.  Drops old events when the user intends
883    // to transfer focus to a new application.
884    EventEntry* mNextUnblockedEvent;
885
886    sp<InputWindowHandle> findTouchedWindowAtLocked(int32_t displayId, int32_t x, int32_t y);
887
888    // All registered connections mapped by channel file descriptor.
889    KeyedVector<int, sp<Connection> > mConnectionsByFd;
890
891    ssize_t getConnectionIndexLocked(const sp<InputChannel>& inputChannel);
892
893    // Input channels that will receive a copy of all input events.
894    Vector<sp<InputChannel> > mMonitoringChannels;
895
896    // Event injection and synchronization.
897    Condition mInjectionResultAvailableCondition;
898    bool hasInjectionPermission(int32_t injectorPid, int32_t injectorUid);
899    void setInjectionResultLocked(EventEntry* entry, int32_t injectionResult);
900
901    Condition mInjectionSyncFinishedCondition;
902    void incrementPendingForegroundDispatchesLocked(EventEntry* entry);
903    void decrementPendingForegroundDispatchesLocked(EventEntry* entry);
904
905    // Key repeat tracking.
906    struct KeyRepeatState {
907        KeyEntry* lastKeyEntry; // or null if no repeat
908        nsecs_t nextRepeatTime;
909    } mKeyRepeatState;
910
911    void resetKeyRepeatLocked();
912    KeyEntry* synthesizeKeyRepeatLocked(nsecs_t currentTime);
913
914    // Key replacement tracking
915    struct KeyReplacement {
916        int32_t keyCode;
917        int32_t deviceId;
918        bool operator==(const KeyReplacement& rhs) const {
919            return keyCode == rhs.keyCode && deviceId == rhs.deviceId;
920        }
921        bool operator<(const KeyReplacement& rhs) const {
922            return keyCode != rhs.keyCode ? keyCode < rhs.keyCode : deviceId < rhs.deviceId;
923        }
924    };
925    // Maps the key code replaced, device id tuple to the key code it was replaced with
926    KeyedVector<KeyReplacement, int32_t> mReplacedKeys;
927
928    // Deferred command processing.
929    bool haveCommandsLocked() const;
930    bool runCommandsLockedInterruptible();
931    CommandEntry* postCommandLocked(Command command);
932
933    // Input filter processing.
934    bool shouldSendKeyToInputFilterLocked(const NotifyKeyArgs* args);
935    bool shouldSendMotionToInputFilterLocked(const NotifyMotionArgs* args);
936
937    // Inbound event processing.
938    void drainInboundQueueLocked();
939    void releasePendingEventLocked();
940    void releaseInboundEventLocked(EventEntry* entry);
941
942    // Dispatch state.
943    bool mDispatchEnabled;
944    bool mDispatchFrozen;
945    bool mInputFilterEnabled;
946
947    Vector<sp<InputWindowHandle> > mWindowHandles;
948
949    sp<InputWindowHandle> getWindowHandleLocked(const sp<InputChannel>& inputChannel) const;
950    bool hasWindowHandleLocked(const sp<InputWindowHandle>& windowHandle) const;
951
952    // Focus tracking for keys, trackball, etc.
953    sp<InputWindowHandle> mFocusedWindowHandle;
954
955    // Focus tracking for touch.
956    struct TouchedWindow {
957        sp<InputWindowHandle> windowHandle;
958        int32_t targetFlags;
959        BitSet32 pointerIds;        // zero unless target flag FLAG_SPLIT is set
960    };
961    struct TouchState {
962        bool down;
963        bool split;
964        int32_t deviceId; // id of the device that is currently down, others are rejected
965        uint32_t source;  // source of the device that is current down, others are rejected
966        int32_t displayId; // id to the display that currently has a touch, others are rejected
967        Vector<TouchedWindow> windows;
968
969        TouchState();
970        ~TouchState();
971        void reset();
972        void copyFrom(const TouchState& other);
973        void addOrUpdateWindow(const sp<InputWindowHandle>& windowHandle,
974                int32_t targetFlags, BitSet32 pointerIds);
975        void removeWindow(const sp<InputWindowHandle>& windowHandle);
976        void filterNonAsIsTouchWindows();
977        sp<InputWindowHandle> getFirstForegroundWindowHandle() const;
978        bool isSlippery() const;
979    };
980
981    KeyedVector<int32_t, TouchState> mTouchStatesByDisplay;
982    TouchState mTempTouchState;
983
984    // Focused application.
985    sp<InputApplicationHandle> mFocusedApplicationHandle;
986
987    // Dispatcher state at time of last ANR.
988    String8 mLastANRState;
989
990    // Dispatch inbound events.
991    bool dispatchConfigurationChangedLocked(
992            nsecs_t currentTime, ConfigurationChangedEntry* entry);
993    bool dispatchDeviceResetLocked(
994            nsecs_t currentTime, DeviceResetEntry* entry);
995    bool dispatchKeyLocked(
996            nsecs_t currentTime, KeyEntry* entry,
997            DropReason* dropReason, nsecs_t* nextWakeupTime);
998    bool dispatchMotionLocked(
999            nsecs_t currentTime, MotionEntry* entry,
1000            DropReason* dropReason, nsecs_t* nextWakeupTime);
1001    void dispatchEventLocked(nsecs_t currentTime, EventEntry* entry,
1002            const Vector<InputTarget>& inputTargets);
1003
1004    void logOutboundKeyDetailsLocked(const char* prefix, const KeyEntry* entry);
1005    void logOutboundMotionDetailsLocked(const char* prefix, const MotionEntry* entry);
1006
1007    // Keeping track of ANR timeouts.
1008    enum InputTargetWaitCause {
1009        INPUT_TARGET_WAIT_CAUSE_NONE,
1010        INPUT_TARGET_WAIT_CAUSE_SYSTEM_NOT_READY,
1011        INPUT_TARGET_WAIT_CAUSE_APPLICATION_NOT_READY,
1012    };
1013
1014    InputTargetWaitCause mInputTargetWaitCause;
1015    nsecs_t mInputTargetWaitStartTime;
1016    nsecs_t mInputTargetWaitTimeoutTime;
1017    bool mInputTargetWaitTimeoutExpired;
1018    sp<InputApplicationHandle> mInputTargetWaitApplicationHandle;
1019
1020    // Contains the last window which received a hover event.
1021    sp<InputWindowHandle> mLastHoverWindowHandle;
1022
1023    // Finding targets for input events.
1024    int32_t handleTargetsNotReadyLocked(nsecs_t currentTime, const EventEntry* entry,
1025            const sp<InputApplicationHandle>& applicationHandle,
1026            const sp<InputWindowHandle>& windowHandle,
1027            nsecs_t* nextWakeupTime, const char* reason);
1028    void resumeAfterTargetsNotReadyTimeoutLocked(nsecs_t newTimeout,
1029            const sp<InputChannel>& inputChannel);
1030    nsecs_t getTimeSpentWaitingForApplicationLocked(nsecs_t currentTime);
1031    void resetANRTimeoutsLocked();
1032
1033    int32_t findFocusedWindowTargetsLocked(nsecs_t currentTime, const EventEntry* entry,
1034            Vector<InputTarget>& inputTargets, nsecs_t* nextWakeupTime);
1035    int32_t findTouchedWindowTargetsLocked(nsecs_t currentTime, const MotionEntry* entry,
1036            Vector<InputTarget>& inputTargets, nsecs_t* nextWakeupTime,
1037            bool* outConflictingPointerActions);
1038
1039    void addWindowTargetLocked(const sp<InputWindowHandle>& windowHandle,
1040            int32_t targetFlags, BitSet32 pointerIds, Vector<InputTarget>& inputTargets);
1041    void addMonitoringTargetsLocked(Vector<InputTarget>& inputTargets);
1042
1043    void pokeUserActivityLocked(const EventEntry* eventEntry);
1044    bool checkInjectionPermission(const sp<InputWindowHandle>& windowHandle,
1045            const InjectionState* injectionState);
1046    bool isWindowObscuredAtPointLocked(const sp<InputWindowHandle>& windowHandle,
1047            int32_t x, int32_t y) const;
1048    String8 getApplicationWindowLabelLocked(const sp<InputApplicationHandle>& applicationHandle,
1049            const sp<InputWindowHandle>& windowHandle);
1050
1051    String8 checkWindowReadyForMoreInputLocked(nsecs_t currentTime,
1052            const sp<InputWindowHandle>& windowHandle, const EventEntry* eventEntry,
1053            const char* targetType);
1054
1055    // Manage the dispatch cycle for a single connection.
1056    // These methods are deliberately not Interruptible because doing all of the work
1057    // with the mutex held makes it easier to ensure that connection invariants are maintained.
1058    // If needed, the methods post commands to run later once the critical bits are done.
1059    void prepareDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,
1060            EventEntry* eventEntry, const InputTarget* inputTarget);
1061    void enqueueDispatchEntriesLocked(nsecs_t currentTime, const sp<Connection>& connection,
1062            EventEntry* eventEntry, const InputTarget* inputTarget);
1063    void enqueueDispatchEntryLocked(const sp<Connection>& connection,
1064            EventEntry* eventEntry, const InputTarget* inputTarget, int32_t dispatchMode);
1065    void startDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection);
1066    void finishDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,
1067            uint32_t seq, bool handled);
1068    void abortBrokenDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,
1069            bool notify);
1070    void drainDispatchQueueLocked(Queue<DispatchEntry>* queue);
1071    void releaseDispatchEntryLocked(DispatchEntry* dispatchEntry);
1072    static int handleReceiveCallback(int fd, int events, void* data);
1073
1074    void synthesizeCancelationEventsForAllConnectionsLocked(
1075            const CancelationOptions& options);
1076    void synthesizeCancelationEventsForInputChannelLocked(const sp<InputChannel>& channel,
1077            const CancelationOptions& options);
1078    void synthesizeCancelationEventsForConnectionLocked(const sp<Connection>& connection,
1079            const CancelationOptions& options);
1080
1081    // Splitting motion events across windows.
1082    MotionEntry* splitMotionEvent(const MotionEntry* originalMotionEntry, BitSet32 pointerIds);
1083
1084    // Reset and drop everything the dispatcher is doing.
1085    void resetAndDropEverythingLocked(const char* reason);
1086
1087    // Dump state.
1088    void dumpDispatchStateLocked(String8& dump);
1089    void logDispatchStateLocked();
1090
1091    // Registration.
1092    void removeMonitorChannelLocked(const sp<InputChannel>& inputChannel);
1093    status_t unregisterInputChannelLocked(const sp<InputChannel>& inputChannel, bool notify);
1094
1095    // Add or remove a connection to the mActiveConnections vector.
1096    void activateConnectionLocked(Connection* connection);
1097    void deactivateConnectionLocked(Connection* connection);
1098
1099    // Interesting events that we might like to log or tell the framework about.
1100    void onDispatchCycleFinishedLocked(
1101            nsecs_t currentTime, const sp<Connection>& connection, uint32_t seq, bool handled);
1102    void onDispatchCycleBrokenLocked(
1103            nsecs_t currentTime, const sp<Connection>& connection);
1104    void onANRLocked(
1105            nsecs_t currentTime, const sp<InputApplicationHandle>& applicationHandle,
1106            const sp<InputWindowHandle>& windowHandle,
1107            nsecs_t eventTime, nsecs_t waitStartTime, const char* reason);
1108
1109    // Outbound policy interactions.
1110    void doNotifyConfigurationChangedInterruptible(CommandEntry* commandEntry);
1111    void doNotifyInputChannelBrokenLockedInterruptible(CommandEntry* commandEntry);
1112    void doNotifyANRLockedInterruptible(CommandEntry* commandEntry);
1113    void doInterceptKeyBeforeDispatchingLockedInterruptible(CommandEntry* commandEntry);
1114    void doDispatchCycleFinishedLockedInterruptible(CommandEntry* commandEntry);
1115    bool afterKeyEventLockedInterruptible(const sp<Connection>& connection,
1116            DispatchEntry* dispatchEntry, KeyEntry* keyEntry, bool handled);
1117    bool afterMotionEventLockedInterruptible(const sp<Connection>& connection,
1118            DispatchEntry* dispatchEntry, MotionEntry* motionEntry, bool handled);
1119    void doPokeUserActivityLockedInterruptible(CommandEntry* commandEntry);
1120    void initializeKeyEvent(KeyEvent* event, const KeyEntry* entry);
1121
1122    // Statistics gathering.
1123    void updateDispatchStatisticsLocked(nsecs_t currentTime, const EventEntry* entry,
1124            int32_t injectionResult, nsecs_t timeSpentWaitingForApplication);
1125    void traceInboundQueueLengthLocked();
1126    void traceOutboundQueueLengthLocked(const sp<Connection>& connection);
1127    void traceWaitQueueLengthLocked(const sp<Connection>& connection);
1128};
1129
1130/* Enqueues and dispatches input events, endlessly. */
1131class InputDispatcherThread : public Thread {
1132public:
1133    explicit InputDispatcherThread(const sp<InputDispatcherInterface>& dispatcher);
1134    ~InputDispatcherThread();
1135
1136private:
1137    virtual bool threadLoop();
1138
1139    sp<InputDispatcherInterface> mDispatcher;
1140};
1141
1142} // namespace android
1143
1144#endif // _UI_INPUT_DISPATCHER_H
1145