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