The Tor Browser / file revision

 /*

  * Copyright (C) 2010 The Android Open Source Project

  *

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  *

  *      http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 #ifndef _UI_INPUT_DISPATCHER_H

 #define _UI_INPUT_DISPATCHER_H

 #include "Input.h"

 #include "InputTransport.h"

 #include <utils/KeyedVector.h>

 #include <utils/Vector.h>

 #include <utils/threads.h>

 #include <utils/Timers.h>

 #include <utils/RefBase.h>

 #include <utils/String8.h>

 #include <utils/Looper.h>

 #include <utils/BitSet.h>

 #include <cutils/atomic.h>

 #include <stddef.h>

 #include <unistd.h>

 #include <limits.h>

 #include "InputWindow.h"

 #include "InputApplication.h"

 #include "InputListener.h"

 namespace android {

 /*

  * Constants used to report the outcome of input event injection.

  */

 enum {

     /* (INTERNAL USE ONLY) Specifies that injection is pending and its outcome is unknown. */

     INPUT_EVENT_INJECTION_PENDING = -1,

     /* Injection succeeded. */

     INPUT_EVENT_INJECTION_SUCCEEDED = 0,

     /* Injection failed because the injector did not have permission to inject

      * into the application with input focus. */

     INPUT_EVENT_INJECTION_PERMISSION_DENIED = 1,

     /* Injection failed because there were no available input targets. */

     INPUT_EVENT_INJECTION_FAILED = 2,

     /* Injection failed due to a timeout. */

     INPUT_EVENT_INJECTION_TIMED_OUT = 3

 };

 /*

  * Constants used to determine the input event injection synchronization mode.

  */

 enum {

     /* Injection is asynchronous and is assumed always to be successful. */

     INPUT_EVENT_INJECTION_SYNC_NONE = 0,

     /* Waits for previous events to be dispatched so that the input dispatcher can determine

      * whether input event injection willbe permitted based on the current input focus.

      * Does not wait for the input event to finish processing. */

     INPUT_EVENT_INJECTION_SYNC_WAIT_FOR_RESULT = 1,

     /* Waits for the input event to be completely processed. */

     INPUT_EVENT_INJECTION_SYNC_WAIT_FOR_FINISHED = 2,

 };

 /*

  * An input target specifies how an input event is to be dispatched to a particular window

  * including the window's input channel, control flags, a timeout, and an X / Y offset to

  * be added to input event coordinates to compensate for the absolute position of the

  * window area.

  */

 struct InputTarget {

     enum {

         /* This flag indicates that the event is being delivered to a foreground application. */

         FLAG_FOREGROUND = 1 << 0,

         /* This flag indicates that the target of a MotionEvent is partly or wholly

          * obscured by another visible window above it.  The motion event should be

          * delivered with flag AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED. */

         FLAG_WINDOW_IS_OBSCURED = 1 << 1,

         /* This flag indicates that a motion event is being split across multiple windows. */

         FLAG_SPLIT = 1 << 2,

         /* This flag indicates that the pointer coordinates dispatched to the application

          * will be zeroed out to avoid revealing information to an application. This is

          * used in conjunction with FLAG_DISPATCH_AS_OUTSIDE to prevent apps not sharing

          * the same UID from watching all touches. */

         FLAG_ZERO_COORDS = 1 << 3,

         /* This flag indicates that the event should be sent as is.

          * Should always be set unless the event is to be transmuted. */

         FLAG_DISPATCH_AS_IS = 1 << 8,

         /* This flag indicates that a MotionEvent with AMOTION_EVENT_ACTION_DOWN falls outside

          * of the area of this target and so should instead be delivered as an

          * AMOTION_EVENT_ACTION_OUTSIDE to this target. */

         FLAG_DISPATCH_AS_OUTSIDE = 1 << 9,

         /* This flag indicates that a hover sequence is starting in the given window.

          * The event is transmuted into ACTION_HOVER_ENTER. */

         FLAG_DISPATCH_AS_HOVER_ENTER = 1 << 10,

         /* This flag indicates that a hover event happened outside of a window which handled

          * previous hover events, signifying the end of the current hover sequence for that

          * window.

          * The event is transmuted into ACTION_HOVER_ENTER. */

         FLAG_DISPATCH_AS_HOVER_EXIT = 1 << 11,

         /* This flag indicates that the event should be canceled.

          * It is used to transmute ACTION_MOVE into ACTION_CANCEL when a touch slips

          * outside of a window. */

         FLAG_DISPATCH_AS_SLIPPERY_EXIT = 1 << 12,

         /* This flag indicates that the event should be dispatched as an initial down.

          * It is used to transmute ACTION_MOVE into ACTION_DOWN when a touch slips

          * into a new window. */

         FLAG_DISPATCH_AS_SLIPPERY_ENTER = 1 << 13,

         /* Mask for all dispatch modes. */

         FLAG_DISPATCH_MASK = FLAG_DISPATCH_AS_IS

                 | FLAG_DISPATCH_AS_OUTSIDE

                 | FLAG_DISPATCH_AS_HOVER_ENTER

                 | FLAG_DISPATCH_AS_HOVER_EXIT

                 | FLAG_DISPATCH_AS_SLIPPERY_EXIT

                 | FLAG_DISPATCH_AS_SLIPPERY_ENTER,

     };

     // The input channel to be targeted.

     sp<InputChannel> inputChannel;

     // Flags for the input target.

     int32_t flags;

     // The x and y offset to add to a MotionEvent as it is delivered.

     // (ignored for KeyEvents)

     float xOffset, yOffset;

     // Scaling factor to apply to MotionEvent as it is delivered.

     // (ignored for KeyEvents)

     float scaleFactor;

     // The subset of pointer ids to include in motion events dispatched to this input target

     // if FLAG_SPLIT is set.

     BitSet32 pointerIds;

 };

 /*

  * Input dispatcher configuration.

  *

  * Specifies various options that modify the behavior of the input dispatcher.

  * The values provided here are merely defaults. The actual values will come from ViewConfiguration

  * and are passed into the dispatcher during initialization.

  */

 struct InputDispatcherConfiguration {

     // The key repeat initial timeout.

     nsecs_t keyRepeatTimeout;

     // The key repeat inter-key delay.

     nsecs_t keyRepeatDelay;

     InputDispatcherConfiguration() :

             keyRepeatTimeout(500 * 1000000LL),

             keyRepeatDelay(50 * 1000000LL) { }

 };

 /*

  * Input dispatcher policy interface.

  *

  * The input reader policy is used by the input reader to interact with the Window Manager

  * and other system components.

  *

  * The actual implementation is partially supported by callbacks into the DVM

  * via JNI.  This interface is also mocked in the unit tests.

  */

 class InputDispatcherPolicyInterface : public virtual RefBase {

 protected:

     InputDispatcherPolicyInterface() { }

     virtual ~InputDispatcherPolicyInterface() { }

 public:

     /* Notifies the system that a configuration change has occurred. */

     virtual void notifyConfigurationChanged(nsecs_t when) = 0;

     /* Notifies the system that an application is not responding.

      * Returns a new timeout to continue waiting, or 0 to abort dispatch. */

     virtual nsecs_t notifyANR(const sp<InputApplicationHandle>& inputApplicationHandle,

             const sp<InputWindowHandle>& inputWindowHandle) = 0;

     /* Notifies the system that an input channel is unrecoverably broken. */

     virtual void notifyInputChannelBroken(const sp<InputWindowHandle>& inputWindowHandle) = 0;

     /* Gets the input dispatcher configuration. */

     virtual void getDispatcherConfiguration(InputDispatcherConfiguration* outConfig) = 0;

     /* Returns true if automatic key repeating is enabled. */

     virtual bool isKeyRepeatEnabled() = 0;

     /* Filters an input event.

      * Return true to dispatch the event unmodified, false to consume the event.

      * A filter can also transform and inject events later by passing POLICY_FLAG_FILTERED

      * to injectInputEvent.

      */

     virtual bool filterInputEvent(const InputEvent* inputEvent, uint32_t policyFlags) = 0;

     /* Intercepts a key event immediately before queueing it.

      * The policy can use this method as an opportunity to perform power management functions

      * and early event preprocessing such as updating policy flags.

      *

      * This method is expected to set the POLICY_FLAG_PASS_TO_USER policy flag if the event

      * should be dispatched to applications.

      */

     virtual void interceptKeyBeforeQueueing(const KeyEvent* keyEvent, uint32_t& policyFlags) = 0;

     /* Intercepts a touch, trackball or other motion event before queueing it.

      * The policy can use this method as an opportunity to perform power management functions

      * and early event preprocessing such as updating policy flags.

      *

      * This method is expected to set the POLICY_FLAG_PASS_TO_USER policy flag if the event

      * should be dispatched to applications.

      */

     virtual void interceptMotionBeforeQueueing(nsecs_t when, uint32_t& policyFlags) = 0;

     /* Allows the policy a chance to intercept a key before dispatching. */

     virtual nsecs_t interceptKeyBeforeDispatching(const sp<InputWindowHandle>& inputWindowHandle,

             const KeyEvent* keyEvent, uint32_t policyFlags) = 0;

     /* Allows the policy a chance to perform default processing for an unhandled key.

      * Returns an alternate keycode to redispatch as a fallback, or 0 to give up. */

     virtual bool dispatchUnhandledKey(const sp<InputWindowHandle>& inputWindowHandle,

             const KeyEvent* keyEvent, uint32_t policyFlags, KeyEvent* outFallbackKeyEvent) = 0;

     /* Notifies the policy about switch events.

      */

     virtual void notifySwitch(nsecs_t when,

             uint32_t switchValues, uint32_t switchMask, uint32_t policyFlags) = 0;

     /* Poke user activity for an event dispatched to a window. */

     virtual void pokeUserActivity(nsecs_t eventTime, int32_t eventType) = 0;

     /* Checks whether a given application pid/uid has permission to inject input events

      * into other applications.

      *

      * This method is special in that its implementation promises to be non-reentrant and

      * is safe to call while holding other locks.  (Most other methods make no such guarantees!)

      */

     virtual bool checkInjectEventsPermissionNonReentrant(

             int32_t injectorPid, int32_t injectorUid) = 0;

 };

 /* Notifies the system about input events generated by the input reader.

  * The dispatcher is expected to be mostly asynchronous. */

 class InputDispatcherInterface : public virtual RefBase, public InputListenerInterface {

 protected:

     InputDispatcherInterface() { }

     virtual ~InputDispatcherInterface() { }

 public:

     /* Dumps the state of the input dispatcher.

      *

      * This method may be called on any thread (usually by the input manager). */

     virtual void dump(String8& dump) = 0;

     /* Called by the heatbeat to ensures that the dispatcher has not deadlocked. */

     virtual void monitor() = 0;

     /* Runs a single iteration of the dispatch loop.

      * Nominally processes one queued event, a timeout, or a response from an input consumer.

      *

      * This method should only be called on the input dispatcher thread.

      */

     virtual void dispatchOnce() = 0;

     /* Injects an input event and optionally waits for sync.

      * The synchronization mode determines whether the method blocks while waiting for

      * input injection to proceed.

      * Returns one of the INPUT_EVENT_INJECTION_XXX constants.

      *

      * This method may be called on any thread (usually by the input manager).

      */

     virtual int32_t injectInputEvent(const InputEvent* event,

             int32_t injectorPid, int32_t injectorUid, int32_t syncMode, int32_t timeoutMillis,

             uint32_t policyFlags) = 0;

     /* Sets the list of input windows.

      *

      * This method may be called on any thread (usually by the input manager).

      */

     virtual void setInputWindows(const Vector<sp<InputWindowHandle> >& inputWindowHandles) = 0;

     /* Sets the focused application.

      *

      * This method may be called on any thread (usually by the input manager).

      */

     virtual void setFocusedApplication(

             const sp<InputApplicationHandle>& inputApplicationHandle) = 0;

     /* Sets the input dispatching mode.

      *

      * This method may be called on any thread (usually by the input manager).

      */

     virtual void setInputDispatchMode(bool enabled, bool frozen) = 0;

     /* Sets whether input event filtering is enabled.

      * When enabled, incoming input events are sent to the policy's filterInputEvent

      * method instead of being dispatched.  The filter is expected to use

      * injectInputEvent to inject the events it would like to have dispatched.

      * It should include POLICY_FLAG_FILTERED in the policy flags during injection.

      */

     virtual void setInputFilterEnabled(bool enabled) = 0;

     /* Transfers touch focus from the window associated with one channel to the

      * window associated with the other channel.

      *

      * Returns true on success.  False if the window did not actually have touch focus.

      */

     virtual bool transferTouchFocus(const sp<InputChannel>& fromChannel,

             const sp<InputChannel>& toChannel) = 0;

     /* Registers or unregister input channels that may be used as targets for input events.

      * If monitor is true, the channel will receive a copy of all input events.

      *

      * These methods may be called on any thread (usually by the input manager).

      */

     virtual status_t registerInputChannel(const sp<InputChannel>& inputChannel,

             const sp<InputWindowHandle>& inputWindowHandle, bool monitor) = 0;

     virtual status_t unregisterInputChannel(const sp<InputChannel>& inputChannel) = 0;

 };

 /* Dispatches events to input targets.  Some functions of the input dispatcher, such as

  * identifying input targets, are controlled by a separate policy object.

  *

  * IMPORTANT INVARIANT:

  *     Because the policy can potentially block or cause re-entrance into the input dispatcher,

  *     the input dispatcher never calls into the policy while holding its internal locks.

  *     The implementation is also carefully designed to recover from scenarios such as an

  *     input channel becoming unregistered while identifying input targets or processing timeouts.

  *

  *     Methods marked 'Locked' must be called with the lock acquired.

  *

  *     Methods marked 'LockedInterruptible' must be called with the lock acquired but

  *     may during the course of their execution release the lock, call into the policy, and

  *     then reacquire the lock.  The caller is responsible for recovering gracefully.

  *

  *     A 'LockedInterruptible' method may called a 'Locked' method, but NOT vice-versa.

  */

 class InputDispatcher : public InputDispatcherInterface {

 protected:

     virtual ~InputDispatcher();

 public:

     explicit InputDispatcher(const sp<InputDispatcherPolicyInterface>& policy);

     virtual void dump(String8& dump);

     virtual void monitor();

     virtual void dispatchOnce();

     virtual void notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args);

     virtual void notifyKey(const NotifyKeyArgs* args);

     virtual void notifyMotion(const NotifyMotionArgs* args);

     virtual void notifySwitch(const NotifySwitchArgs* args);

     virtual void notifyDeviceReset(const NotifyDeviceResetArgs* args);

     virtual int32_t injectInputEvent(const InputEvent* event,

             int32_t injectorPid, int32_t injectorUid, int32_t syncMode, int32_t timeoutMillis,

             uint32_t policyFlags);

     virtual void setInputWindows(const Vector<sp<InputWindowHandle> >& inputWindowHandles);

     virtual void setFocusedApplication(const sp<InputApplicationHandle>& inputApplicationHandle);

     virtual void setInputDispatchMode(bool enabled, bool frozen);

     virtual void setInputFilterEnabled(bool enabled);

     virtual bool transferTouchFocus(const sp<InputChannel>& fromChannel,

             const sp<InputChannel>& toChannel);

     virtual status_t registerInputChannel(const sp<InputChannel>& inputChannel,

             const sp<InputWindowHandle>& inputWindowHandle, bool monitor);

     virtual status_t unregisterInputChannel(const sp<InputChannel>& inputChannel);

 private:

     template <typename T>

     struct Link {

         T* next;

         T* prev;

     protected:

         inline Link() : next(NULL), prev(NULL) { }

     };

     struct InjectionState {

         mutable int32_t refCount;

         int32_t injectorPid;

         int32_t injectorUid;

         int32_t injectionResult;  // initially INPUT_EVENT_INJECTION_PENDING

         bool injectionIsAsync; // set to true if injection is not waiting for the result

         int32_t pendingForegroundDispatches; // the number of foreground dispatches in progress

         InjectionState(int32_t injectorPid, int32_t injectorUid);

         void release();

     private:

         ~InjectionState();

     };

     struct EventEntry : Link<EventEntry> {

         enum {

             TYPE_CONFIGURATION_CHANGED,

             TYPE_DEVICE_RESET,

             TYPE_KEY,

             TYPE_MOTION

         };

         mutable int32_t refCount;

         int32_t type;

         nsecs_t eventTime;

         uint32_t policyFlags;

         InjectionState* injectionState;

         bool dispatchInProgress; // initially false, set to true while dispatching

         inline bool isInjected() const { return injectionState != NULL; }

         void release();

         virtual void appendDescription(String8& msg) const = 0;

     protected:

         EventEntry(int32_t type, nsecs_t eventTime, uint32_t policyFlags);

         virtual ~EventEntry();

         void releaseInjectionState();

     };

     struct ConfigurationChangedEntry : EventEntry {

         ConfigurationChangedEntry(nsecs_t eventTime);

         virtual void appendDescription(String8& msg) const;

     protected:

         virtual ~ConfigurationChangedEntry();

     };

     struct DeviceResetEntry : EventEntry {

         int32_t deviceId;

         DeviceResetEntry(nsecs_t eventTime, int32_t deviceId);

         virtual void appendDescription(String8& msg) const;

     protected:

         virtual ~DeviceResetEntry();

     };

     struct KeyEntry : EventEntry {

         int32_t deviceId;

         uint32_t source;

         int32_t action;

         int32_t flags;

         int32_t keyCode;

         int32_t scanCode;

         int32_t metaState;

         int32_t repeatCount;

         nsecs_t downTime;

         bool syntheticRepeat; // set to true for synthetic key repeats

         enum InterceptKeyResult {

             INTERCEPT_KEY_RESULT_UNKNOWN,

             INTERCEPT_KEY_RESULT_SKIP,

             INTERCEPT_KEY_RESULT_CONTINUE,

             INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER,

         };

         InterceptKeyResult interceptKeyResult; // set based on the interception result

         nsecs_t interceptKeyWakeupTime; // used with INTERCEPT_KEY_RESULT_TRY_AGAIN_LATER

         KeyEntry(nsecs_t eventTime,

                 int32_t deviceId, uint32_t source, uint32_t policyFlags, int32_t action,

                 int32_t flags, int32_t keyCode, int32_t scanCode, int32_t metaState,

                 int32_t repeatCount, nsecs_t downTime);

         virtual void appendDescription(String8& msg) const;

         void recycle();

     protected:

         virtual ~KeyEntry();

     };

     struct MotionEntry : EventEntry {

         nsecs_t eventTime;

         int32_t deviceId;

         uint32_t source;

         int32_t action;

         int32_t flags;

         int32_t metaState;

         int32_t buttonState;

         int32_t edgeFlags;

         float xPrecision;

         float yPrecision;

         nsecs_t downTime;

         int32_t displayId;

         uint32_t pointerCount;

         PointerProperties pointerProperties[MAX_POINTERS];

         PointerCoords pointerCoords[MAX_POINTERS];

         MotionEntry(nsecs_t eventTime,

                 int32_t deviceId, uint32_t source, uint32_t policyFlags,

                 int32_t action, int32_t flags,

                 int32_t metaState, int32_t buttonState, int32_t edgeFlags,

                 float xPrecision, float yPrecision,

                 nsecs_t downTime, int32_t displayId, uint32_t pointerCount,

                 const PointerProperties* pointerProperties, const PointerCoords* pointerCoords);

         virtual void appendDescription(String8& msg) const;

     protected:

         virtual ~MotionEntry();

     };

     // Tracks the progress of dispatching a particular event to a particular connection.

     struct DispatchEntry : Link<DispatchEntry> {

         const uint32_t seq; // unique sequence number, never 0

         EventEntry* eventEntry; // the event to dispatch

         int32_t targetFlags;

         float xOffset;

         float yOffset;

         float scaleFactor;

         nsecs_t deliveryTime; // time when the event was actually delivered

         // Set to the resolved action and flags when the event is enqueued.

         int32_t resolvedAction;

         int32_t resolvedFlags;

         DispatchEntry(EventEntry* eventEntry,

                 int32_t targetFlags, float xOffset, float yOffset, float scaleFactor);

         ~DispatchEntry();

         inline bool hasForegroundTarget() const {

             return targetFlags & InputTarget::FLAG_FOREGROUND;

         }

         inline bool isSplit() const {

             return targetFlags & InputTarget::FLAG_SPLIT;

         }

     private:

         static volatile int32_t sNextSeqAtomic;

         static uint32_t nextSeq();

     };

     // A command entry captures state and behavior for an action to be performed in the

     // dispatch loop after the initial processing has taken place.  It is essentially

     // a kind of continuation used to postpone sensitive policy interactions to a point

     // in the dispatch loop where it is safe to release the lock (generally after finishing

     // the critical parts of the dispatch cycle).

     //

     // The special thing about commands is that they can voluntarily release and reacquire

     // the dispatcher lock at will.  Initially when the command starts running, the

     // dispatcher lock is held.  However, if the command needs to call into the policy to

     // do some work, it can release the lock, do the work, then reacquire the lock again

     // before returning.

     //

     // This mechanism is a bit clunky but it helps to preserve the invariant that the dispatch

     // never calls into the policy while holding its lock.

     //

     // Commands are implicitly 'LockedInterruptible'.

     struct CommandEntry;

     typedef void (InputDispatcher::*Command)(CommandEntry* commandEntry);

     class Connection;

     struct CommandEntry : Link<CommandEntry> {

         CommandEntry(Command command);

         ~CommandEntry();

         Command command;

         // parameters for the command (usage varies by command)

         sp<Connection> connection;

         nsecs_t eventTime;

         KeyEntry* keyEntry;

         sp<InputApplicationHandle> inputApplicationHandle;

         sp<InputWindowHandle> inputWindowHandle;

         int32_t userActivityEventType;

         uint32_t seq;

         bool handled;

     };

     // Generic queue implementation.

     template <typename T>

     struct Queue {

         T* head;

         T* tail;

         inline Queue() : head(NULL), tail(NULL) {

         }

         inline bool isEmpty() const {

             return !head;

         }

         inline void enqueueAtTail(T* entry) {

             entry->prev = tail;

             if (tail) {

                 tail->next = entry;

             } else {

                 head = entry;

             }

             entry->next = NULL;

             tail = entry;

         }

         inline void enqueueAtHead(T* entry) {

             entry->next = head;

             if (head) {

                 head->prev = entry;

             } else {

                 tail = entry;

             }

             entry->prev = NULL;

             head = entry;

         }

         inline void dequeue(T* entry) {

             if (entry->prev) {

                 entry->prev->next = entry->next;

             } else {

                 head = entry->next;

             }

             if (entry->next) {

                 entry->next->prev = entry->prev;

             } else {

                 tail = entry->prev;

             }

         }

         inline T* dequeueAtHead() {

             T* entry = head;

             head = entry->next;

             if (head) {

                 head->prev = NULL;

             } else {

                 tail = NULL;

             }

             return entry;

         }

         uint32_t count() const;

     };

     /* Specifies which events are to be canceled and why. */

     struct CancelationOptions {

         enum Mode {

             CANCEL_ALL_EVENTS = 0,

             CANCEL_POINTER_EVENTS = 1,

             CANCEL_NON_POINTER_EVENTS = 2,

             CANCEL_FALLBACK_EVENTS = 3,

         };

         // The criterion to use to determine which events should be canceled.

         Mode mode;

         // Descriptive reason for the cancelation.

         const char* reason;

         // The specific keycode of the key event to cancel, or -1 to cancel any key event.

         int32_t keyCode;

         // The specific device id of events to cancel, or -1 to cancel events from any device.

         int32_t deviceId;

         CancelationOptions(Mode mode, const char* reason) :

                 mode(mode), reason(reason), keyCode(-1), deviceId(-1) { }

     };

     /* Tracks dispatched key and motion event state so that cancelation events can be

      * synthesized when events are dropped. */

     class InputState {

     public:

         InputState();

         ~InputState();

         // Returns true if there is no state to be canceled.

         bool isNeutral() const;

         // Returns true if the specified source is known to have received a hover enter

         // motion event.

         bool isHovering(int32_t deviceId, uint32_t source, int32_t displayId) const;

         // Records tracking information for a key event that has just been published.

         // Returns true if the event should be delivered, false if it is inconsistent

         // and should be skipped.

         bool trackKey(const KeyEntry* entry, int32_t action, int32_t flags);

         // Records tracking information for a motion event that has just been published.

         // Returns true if the event should be delivered, false if it is inconsistent

         // and should be skipped.

         bool trackMotion(const MotionEntry* entry, int32_t action, int32_t flags);

         // Synthesizes cancelation events for the current state and resets the tracked state.

         void synthesizeCancelationEvents(nsecs_t currentTime,

                 Vector<EventEntry*>& outEvents, const CancelationOptions& options);

         // Clears the current state.

         void clear();

         // Copies pointer-related parts of the input state to another instance.

         void copyPointerStateTo(InputState& other) const;

         // Gets the fallback key associated with a keycode.

         // Returns -1 if none.

         // Returns AKEYCODE_UNKNOWN if we are only dispatching the unhandled key to the policy.

         int32_t getFallbackKey(int32_t originalKeyCode);

         // Sets the fallback key for a particular keycode.

         void setFallbackKey(int32_t originalKeyCode, int32_t fallbackKeyCode);

         // Removes the fallback key for a particular keycode.

         void removeFallbackKey(int32_t originalKeyCode);

         inline const KeyedVector<int32_t, int32_t>& getFallbackKeys() const {

             return mFallbackKeys;

         }

     private:

         struct KeyMemento {

             int32_t deviceId;

             uint32_t source;

             int32_t keyCode;

             int32_t scanCode;

             int32_t metaState;

             int32_t flags;

             nsecs_t downTime;

             uint32_t policyFlags;

         };

         struct MotionMemento {

             int32_t deviceId;

             uint32_t source;

             int32_t flags;

             float xPrecision;

             float yPrecision;

             nsecs_t downTime;

             int32_t displayId;

             uint32_t pointerCount;

             PointerProperties pointerProperties[MAX_POINTERS];

             PointerCoords pointerCoords[MAX_POINTERS];

             bool hovering;

             uint32_t policyFlags;

             void setPointers(const MotionEntry* entry);

         };

         Vector<KeyMemento> mKeyMementos;

         Vector<MotionMemento> mMotionMementos;

         KeyedVector<int32_t, int32_t> mFallbackKeys;

         ssize_t findKeyMemento(const KeyEntry* entry) const;

         ssize_t findMotionMemento(const MotionEntry* entry, bool hovering) const;

         void addKeyMemento(const KeyEntry* entry, int32_t flags);

         void addMotionMemento(const MotionEntry* entry, int32_t flags, bool hovering);

         static bool shouldCancelKey(const KeyMemento& memento,

                 const CancelationOptions& options);

         static bool shouldCancelMotion(const MotionMemento& memento,

                 const CancelationOptions& options);

     };

     /* Manages the dispatch state associated with a single input channel. */

     class Connection : public RefBase {

     protected:

         virtual ~Connection();

     public:

         enum Status {

             // Everything is peachy.

             STATUS_NORMAL,

             // An unrecoverable communication error has occurred.

             STATUS_BROKEN,

             // The input channel has been unregistered.

             STATUS_ZOMBIE

         };

         Status status;

         sp<InputChannel> inputChannel; // never null

         sp<InputWindowHandle> inputWindowHandle; // may be null

         bool monitor;

         InputPublisher inputPublisher;

         InputState inputState;

         // True if the socket is full and no further events can be published until

         // the application consumes some of the input.

         bool inputPublisherBlocked;

         // Queue of events that need to be published to the connection.

         Queue<DispatchEntry> outboundQueue;

         // Queue of events that have been published to the connection but that have not

         // yet received a "finished" response from the application.

         Queue<DispatchEntry> waitQueue;

         explicit Connection(const sp<InputChannel>& inputChannel,

                 const sp<InputWindowHandle>& inputWindowHandle, bool monitor);

         inline const char* getInputChannelName() const { return inputChannel->getName().string(); }

         const char* getWindowName() const;

         const char* getStatusLabel() const;

         DispatchEntry* findWaitQueueEntry(uint32_t seq);

     };

     enum DropReason {

         DROP_REASON_NOT_DROPPED = 0,

         DROP_REASON_POLICY = 1,

         DROP_REASON_APP_SWITCH = 2,

         DROP_REASON_DISABLED = 3,

         DROP_REASON_BLOCKED = 4,

         DROP_REASON_STALE = 5,

     };

     sp<InputDispatcherPolicyInterface> mPolicy;

     InputDispatcherConfiguration mConfig;

     Mutex mLock;

     Condition mDispatcherIsAliveCondition;

     sp<Looper> mLooper;

     EventEntry* mPendingEvent;

     Queue<EventEntry> mInboundQueue;

     Queue<CommandEntry> mCommandQueue;

     void dispatchOnceInnerLocked(nsecs_t* nextWakeupTime);

     // Enqueues an inbound event.  Returns true if mLooper->wake() should be called.

     bool enqueueInboundEventLocked(EventEntry* entry);

     // Cleans up input state when dropping an inbound event.

     void dropInboundEventLocked(EventEntry* entry, DropReason dropReason);

     // App switch latency optimization.

     bool mAppSwitchSawKeyDown;

     nsecs_t mAppSwitchDueTime;

     static bool isAppSwitchKeyCode(int32_t keyCode);

     bool isAppSwitchKeyEventLocked(KeyEntry* keyEntry);

     bool isAppSwitchPendingLocked();

     void resetPendingAppSwitchLocked(bool handled);

     // Stale event latency optimization.

     static bool isStaleEventLocked(nsecs_t currentTime, EventEntry* entry);

     // Blocked event latency optimization.  Drops old events when the user intends

     // to transfer focus to a new application.

     EventEntry* mNextUnblockedEvent;

     sp<InputWindowHandle> findTouchedWindowAtLocked(int32_t displayId, int32_t x, int32_t y);

     // All registered connections mapped by channel file descriptor.

     KeyedVector<int, sp<Connection> > mConnectionsByFd;

     ssize_t getConnectionIndexLocked(const sp<InputChannel>& inputChannel);

     // Input channels that will receive a copy of all input events.

     Vector<sp<InputChannel> > mMonitoringChannels;

     // Event injection and synchronization.

     Condition mInjectionResultAvailableCondition;

     bool hasInjectionPermission(int32_t injectorPid, int32_t injectorUid);

     void setInjectionResultLocked(EventEntry* entry, int32_t injectionResult);

     Condition mInjectionSyncFinishedCondition;

     void incrementPendingForegroundDispatchesLocked(EventEntry* entry);

     void decrementPendingForegroundDispatchesLocked(EventEntry* entry);

     // Key repeat tracking.

     struct KeyRepeatState {

         KeyEntry* lastKeyEntry; // or null if no repeat

         nsecs_t nextRepeatTime;

     } mKeyRepeatState;

     void resetKeyRepeatLocked();

     KeyEntry* synthesizeKeyRepeatLocked(nsecs_t currentTime);

     // Deferred command processing.

     bool haveCommandsLocked() const;

     bool runCommandsLockedInterruptible();

     CommandEntry* postCommandLocked(Command command);

     // Input filter processing.

     bool shouldSendKeyToInputFilterLocked(const NotifyKeyArgs* args);

     bool shouldSendMotionToInputFilterLocked(const NotifyMotionArgs* args);

     // Inbound event processing.

     void drainInboundQueueLocked();

     void releasePendingEventLocked();

     void releaseInboundEventLocked(EventEntry* entry);

     // Dispatch state.

     bool mDispatchEnabled;

     bool mDispatchFrozen;

     bool mInputFilterEnabled;

     Vector<sp<InputWindowHandle> > mWindowHandles;

     sp<InputWindowHandle> getWindowHandleLocked(const sp<InputChannel>& inputChannel) const;

     bool hasWindowHandleLocked(const sp<InputWindowHandle>& windowHandle) const;

     // Focus tracking for keys, trackball, etc.

     sp<InputWindowHandle> mFocusedWindowHandle;

     // Focus tracking for touch.

     struct TouchedWindow {

         sp<InputWindowHandle> windowHandle;

         int32_t targetFlags;

         BitSet32 pointerIds;        // zero unless target flag FLAG_SPLIT is set

     };

     struct TouchState {

         bool down;

         bool split;

         int32_t deviceId; // id of the device that is currently down, others are rejected

         uint32_t source;  // source of the device that is current down, others are rejected

         int32_t displayId; // id to the display that currently has a touch, others are rejected

         Vector<TouchedWindow> windows;

         TouchState();

         ~TouchState();

         void reset();

         void copyFrom(const TouchState& other);

         void addOrUpdateWindow(const sp<InputWindowHandle>& windowHandle,

                 int32_t targetFlags, BitSet32 pointerIds);

         void removeWindow(const sp<InputWindowHandle>& windowHandle);

         void filterNonAsIsTouchWindows();

         sp<InputWindowHandle> getFirstForegroundWindowHandle() const;

         bool isSlippery() const;

     };

     TouchState mTouchState;

     TouchState mTempTouchState;

     // Focused application.

     sp<InputApplicationHandle> mFocusedApplicationHandle;

     // Dispatcher state at time of last ANR.

     String8 mLastANRState;

     // Dispatch inbound events.

     bool dispatchConfigurationChangedLocked(

             nsecs_t currentTime, ConfigurationChangedEntry* entry);

     bool dispatchDeviceResetLocked(

             nsecs_t currentTime, DeviceResetEntry* entry);

     bool dispatchKeyLocked(

             nsecs_t currentTime, KeyEntry* entry,

             DropReason* dropReason, nsecs_t* nextWakeupTime);

     bool dispatchMotionLocked(

             nsecs_t currentTime, MotionEntry* entry,

             DropReason* dropReason, nsecs_t* nextWakeupTime);

     void dispatchEventLocked(nsecs_t currentTime, EventEntry* entry,

             const Vector<InputTarget>& inputTargets);

     void logOutboundKeyDetailsLocked(const char* prefix, const KeyEntry* entry);

     void logOutboundMotionDetailsLocked(const char* prefix, const MotionEntry* entry);

     // Keeping track of ANR timeouts.

     enum InputTargetWaitCause {

         INPUT_TARGET_WAIT_CAUSE_NONE,

         INPUT_TARGET_WAIT_CAUSE_SYSTEM_NOT_READY,

         INPUT_TARGET_WAIT_CAUSE_APPLICATION_NOT_READY,

     };

     InputTargetWaitCause mInputTargetWaitCause;

     nsecs_t mInputTargetWaitStartTime;

     nsecs_t mInputTargetWaitTimeoutTime;

     bool mInputTargetWaitTimeoutExpired;

     sp<InputApplicationHandle> mInputTargetWaitApplicationHandle;

     // Contains the last window which received a hover event.

     sp<InputWindowHandle> mLastHoverWindowHandle;

     // Finding targets for input events.

     int32_t handleTargetsNotReadyLocked(nsecs_t currentTime, const EventEntry* entry,

             const sp<InputApplicationHandle>& applicationHandle,

             const sp<InputWindowHandle>& windowHandle,

             nsecs_t* nextWakeupTime, const char* reason);

     void resumeAfterTargetsNotReadyTimeoutLocked(nsecs_t newTimeout,

             const sp<InputChannel>& inputChannel);

     nsecs_t getTimeSpentWaitingForApplicationLocked(nsecs_t currentTime);

     void resetANRTimeoutsLocked();

     int32_t findFocusedWindowTargetsLocked(nsecs_t currentTime, const EventEntry* entry,

             Vector<InputTarget>& inputTargets, nsecs_t* nextWakeupTime);

     int32_t findTouchedWindowTargetsLocked(nsecs_t currentTime, const MotionEntry* entry,

             Vector<InputTarget>& inputTargets, nsecs_t* nextWakeupTime,

             bool* outConflictingPointerActions);

     void addWindowTargetLocked(const sp<InputWindowHandle>& windowHandle,

             int32_t targetFlags, BitSet32 pointerIds, Vector<InputTarget>& inputTargets);

     void addMonitoringTargetsLocked(Vector<InputTarget>& inputTargets);

     void pokeUserActivityLocked(const EventEntry* eventEntry);

     bool checkInjectionPermission(const sp<InputWindowHandle>& windowHandle,

             const InjectionState* injectionState);

     bool isWindowObscuredAtPointLocked(const sp<InputWindowHandle>& windowHandle,

             int32_t x, int32_t y) const;

     bool isWindowReadyForMoreInputLocked(nsecs_t currentTime,

             const sp<InputWindowHandle>& windowHandle, const EventEntry* eventEntry);

     String8 getApplicationWindowLabelLocked(const sp<InputApplicationHandle>& applicationHandle,

             const sp<InputWindowHandle>& windowHandle);

     // Manage the dispatch cycle for a single connection.

     // These methods are deliberately not Interruptible because doing all of the work

     // with the mutex held makes it easier to ensure that connection invariants are maintained.

     // If needed, the methods post commands to run later once the critical bits are done.

     void prepareDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,

             EventEntry* eventEntry, const InputTarget* inputTarget);

     void enqueueDispatchEntriesLocked(nsecs_t currentTime, const sp<Connection>& connection,

             EventEntry* eventEntry, const InputTarget* inputTarget);

     void enqueueDispatchEntryLocked(const sp<Connection>& connection,

             EventEntry* eventEntry, const InputTarget* inputTarget, int32_t dispatchMode);

     void startDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection);

     void finishDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,

             uint32_t seq, bool handled);

     void abortBrokenDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,

             bool notify);

     void drainDispatchQueueLocked(Queue<DispatchEntry>* queue);

     void releaseDispatchEntryLocked(DispatchEntry* dispatchEntry);

     static int handleReceiveCallback(int fd, int events, void* data);

     void synthesizeCancelationEventsForAllConnectionsLocked(

             const CancelationOptions& options);

     void synthesizeCancelationEventsForInputChannelLocked(const sp<InputChannel>& channel,

             const CancelationOptions& options);

     void synthesizeCancelationEventsForConnectionLocked(const sp<Connection>& connection,

             const CancelationOptions& options);

     // Splitting motion events across windows.

     MotionEntry* splitMotionEvent(const MotionEntry* originalMotionEntry, BitSet32 pointerIds);

     // Reset and drop everything the dispatcher is doing.

     void resetAndDropEverythingLocked(const char* reason);

     // Dump state.

     void dumpDispatchStateLocked(String8& dump);

     void logDispatchStateLocked();

     // Registration.

     void removeMonitorChannelLocked(const sp<InputChannel>& inputChannel);

     status_t unregisterInputChannelLocked(const sp<InputChannel>& inputChannel, bool notify);

     // Add or remove a connection to the mActiveConnections vector.

     void activateConnectionLocked(Connection* connection);

     void deactivateConnectionLocked(Connection* connection);

     // Interesting events that we might like to log or tell the framework about.

     void onDispatchCycleFinishedLocked(

             nsecs_t currentTime, const sp<Connection>& connection, uint32_t seq, bool handled);

     void onDispatchCycleBrokenLocked(

             nsecs_t currentTime, const sp<Connection>& connection);

     void onANRLocked(

             nsecs_t currentTime, const sp<InputApplicationHandle>& applicationHandle,

             const sp<InputWindowHandle>& windowHandle,

             nsecs_t eventTime, nsecs_t waitStartTime, const char* reason);

     // Outbound policy interactions.

     void doNotifyConfigurationChangedInterruptible(CommandEntry* commandEntry);

     void doNotifyInputChannelBrokenLockedInterruptible(CommandEntry* commandEntry);

     void doNotifyANRLockedInterruptible(CommandEntry* commandEntry);

     void doInterceptKeyBeforeDispatchingLockedInterruptible(CommandEntry* commandEntry);

     void doDispatchCycleFinishedLockedInterruptible(CommandEntry* commandEntry);

     bool afterKeyEventLockedInterruptible(const sp<Connection>& connection,

             DispatchEntry* dispatchEntry, KeyEntry* keyEntry, bool handled);

     bool afterMotionEventLockedInterruptible(const sp<Connection>& connection,

             DispatchEntry* dispatchEntry, MotionEntry* motionEntry, bool handled);

     void doPokeUserActivityLockedInterruptible(CommandEntry* commandEntry);

     void initializeKeyEvent(KeyEvent* event, const KeyEntry* entry);

     // Statistics gathering.

     void updateDispatchStatisticsLocked(nsecs_t currentTime, const EventEntry* entry,

             int32_t injectionResult, nsecs_t timeSpentWaitingForApplication);

     void traceInboundQueueLengthLocked();

     void traceOutboundQueueLengthLocked(const sp<Connection>& connection);

     void traceWaitQueueLengthLocked(const sp<Connection>& connection);

 };

 /* Enqueues and dispatches input events, endlessly. */

 class InputDispatcherThread : public Thread {

 public:

     explicit InputDispatcherThread(const sp<InputDispatcherInterface>& dispatcher);

     ~InputDispatcherThread();

 private:

     virtual bool threadLoop();

     sp<InputDispatcherInterface> mDispatcher;

 };

 } // namespace android

 #endif // _UI_INPUT_DISPATCHER_H