android/webkit/WebViewInputDispatcher.java

/*
 * Copyright (C) 2012 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.
 */

package android.webkit;

import android.content.Context;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.SystemClock;
import android.util.Log;
import android.view.InputDevice;
import android.view.MotionEvent;
import android.view.ViewConfiguration;

/**
 * Perform asynchronous dispatch of input events in a {@link WebView}.
 *
 * This dispatcher is shared by the UI thread ({@link WebViewClassic}) and web kit
 * thread ({@link WebViewCore}).  The UI thread enqueues events for
 * processing, waits for the web kit thread to handle them, and then performs
 * additional processing depending on the outcome.
 *
 * How it works:
 *
 * 1. The web view thread receives an input event from the input system on the UI
 * thread in its {@link WebViewClassic#onTouchEvent} handler.  It sends the input event
 * to the dispatcher, then immediately returns true to the input system to indicate that
 * it will handle the event.
 *
 * 2. The web kit thread is notified that an event has been enqueued.  Meanwhile additional
 * events may be enqueued from the UI thread.  In some cases, the dispatcher may decide to
 * coalesce motion events into larger batches or to cancel events that have been
 * sitting in the queue for too long.
 *
 * 3. The web kit thread wakes up and handles all input events that are waiting for it.
 * After processing each input event, it informs the dispatcher whether the web application
 * has decided to handle the event itself and to prevent default event handling.
 *
 * 4. If web kit indicates that it wants to prevent default event handling, then web kit
 * consumes the remainder of the gesture and web view receives a cancel event if
 * needed.  Otherwise, the web view handles the gesture on the UI thread normally.
 *
 * 5. If the web kit thread takes too long to handle an input event, then it loses the
 * right to handle it.  The dispatcher synthesizes a cancellation event for web kit and
 * then tells the web view on the UI thread to handle the event that timed out along
 * with the rest of the gesture.
 *
 * One thing to keep in mind about the dispatcher is that what goes into the dispatcher
 * is not necessarily what the web kit or UI thread will see.  As mentioned above, the
 * dispatcher may tweak the input event stream to improve responsiveness.  Both web view and
 * web kit are guaranteed to perceive a consistent stream of input events but
 * they might not always see the same events (especially if one decides
 * to prevent the other from handling a particular gesture).
 *
 * This implementation very deliberately does not refer to the {@link WebViewClassic}
 * or {@link WebViewCore} classes, preferring to communicate with them only via
 * interfaces to avoid unintentional coupling to their implementation details.
 *
 * Currently, the input dispatcher only handles pointer events (includes touch,
 * hover and scroll events).  In principle, it could be extended to handle trackball
 * and key events if needed.
 *
 * @hide
 */
final class WebViewInputDispatcher {
    private static final String TAG = "WebViewInputDispatcher";
    private static final boolean DEBUG = false;
    // This enables batching of MotionEvents. It will combine multiple MotionEvents
    // together into a single MotionEvent if more events come in while we are
    // still waiting on the processing of a previous event.
    // If this is set to false, we will instead opt to drop ACTION_MOVE
    // events we cannot keep up with.
    // TODO: If batching proves to be working well, remove this
    private static final boolean ENABLE_EVENT_BATCHING = true;

    private final Object mLock = new Object();

    // Pool of queued input events.  (guarded by mLock)
    private static final int MAX_DISPATCH_EVENT_POOL_SIZE = 10;
    private DispatchEvent mDispatchEventPool;
    private int mDispatchEventPoolSize;

    // Posted state, tracks events posted to the dispatcher.  (guarded by mLock)
    private final TouchStream mPostTouchStream = new TouchStream();
    private boolean mPostSendTouchEventsToWebKit;
    private boolean mPostDoNotSendTouchEventsToWebKitUntilNextGesture;
    private boolean mPostLongPressScheduled;
    private boolean mPostClickScheduled;
    private int mPostLastWebKitXOffset;
    private int mPostLastWebKitYOffset;
    private float mPostLastWebKitScale;

    // State for event tracking (click, longpress, double tap, etc..)
    private boolean mIsDoubleTapCandidate;
    private boolean mIsTapCandidate;
    private float mInitialDownX;
    private float mInitialDownY;
    private float mTouchSlopSquared;
    private float mDoubleTapSlopSquared;

    // Web kit state, tracks events observed by web kit.  (guarded by mLock)
    private final DispatchEventQueue mWebKitDispatchEventQueue = new DispatchEventQueue();
    private final TouchStream mWebKitTouchStream = new TouchStream();
    private final WebKitCallbacks mWebKitCallbacks;
    private final WebKitHandler mWebKitHandler;
    private boolean mWebKitDispatchScheduled;
    private boolean mWebKitTimeoutScheduled;
    private long mWebKitTimeoutTime;

    // UI state, tracks events observed by the UI.  (guarded by mLock)
    private final DispatchEventQueue mUiDispatchEventQueue = new DispatchEventQueue();
    private final TouchStream mUiTouchStream = new TouchStream();
    private final UiCallbacks mUiCallbacks;
    private final UiHandler mUiHandler;
    private boolean mUiDispatchScheduled;

    // Give up on web kit handling of input events when this timeout expires.
    private static final long WEBKIT_TIMEOUT_MILLIS = 200;
    private static final int TAP_TIMEOUT = ViewConfiguration.getTapTimeout();
    private static final int LONG_PRESS_TIMEOUT =
            ViewConfiguration.getLongPressTimeout() + TAP_TIMEOUT;
    private static final int DOUBLE_TAP_TIMEOUT = ViewConfiguration.getDoubleTapTimeout();

    /**
     * Event type: Indicates a touch event type.
     *
     * This event is delivered together with a {@link MotionEvent} with one of the
     * following actions: {@link MotionEvent#ACTION_DOWN}, {@link MotionEvent#ACTION_MOVE},
     * {@link MotionEvent#ACTION_UP}, {@link MotionEvent#ACTION_POINTER_DOWN},
     * {@link MotionEvent#ACTION_POINTER_UP}, {@link MotionEvent#ACTION_CANCEL}.
     */
    public static final int EVENT_TYPE_TOUCH = 0;

    /**
     * Event type: Indicates a hover event type.
     *
     * This event is delivered together with a {@link MotionEvent} with one of the
     * following actions: {@link MotionEvent#ACTION_HOVER_ENTER},
     * {@link MotionEvent#ACTION_HOVER_MOVE}, {@link MotionEvent#ACTION_HOVER_MOVE}.
     */
    public static final int EVENT_TYPE_HOVER = 1;

    /**
     * Event type: Indicates a scroll event type.
     *
     * This event is delivered together with a {@link MotionEvent} with action
     * {@link MotionEvent#ACTION_SCROLL}.
     */
    public static final int EVENT_TYPE_SCROLL = 2;

    /**
     * Event type: Indicates a long-press event type.
     *
     * This event is delivered in the middle of a sequence of {@link #EVENT_TYPE_TOUCH} events.
     * It includes a {@link MotionEvent} with action {@link MotionEvent#ACTION_MOVE}
     * that indicates the current touch coordinates of the long-press.
     *
     * This event is sent when the current touch gesture has been held longer than
     * the long-press interval.
     */
    public static final int EVENT_TYPE_LONG_PRESS = 3;

    /**
     * Event type: Indicates a click event type.
     *
     * This event is delivered after a sequence of {@link #EVENT_TYPE_TOUCH} events that
     * comprise a complete gesture ending with {@link MotionEvent#ACTION_UP}.
     * It includes a {@link MotionEvent} with action {@link MotionEvent#ACTION_UP}
     * that indicates the location of the click.
     *
     * This event is sent shortly after the end of a touch after the double-tap
     * interval has expired to indicate a click.
     */
    public static final int EVENT_TYPE_CLICK = 4;

    /**
     * Event type: Indicates a double-tap event type.
     *
     * This event is delivered after a sequence of {@link #EVENT_TYPE_TOUCH} events that
     * comprise a complete gesture ending with {@link MotionEvent#ACTION_UP}.
     * It includes a {@link MotionEvent} with action {@link MotionEvent#ACTION_UP}
     * that indicates the location of the double-tap.
     *
     * This event is sent immediately after a sequence of two touches separated
     * in time by no more than the double-tap interval and separated in space
     * by no more than the double-tap slop.
     */
    public static final int EVENT_TYPE_DOUBLE_TAP = 5;

    /**
     * Flag: This event is private to this queue.  Do not forward it.
     */
    public static final int FLAG_PRIVATE = 1 << 0;

    /**
     * Flag: This event is currently being processed by web kit.
     * If a timeout occurs, make a copy of it before forwarding the event to another queue.
     */
    public static final int FLAG_WEBKIT_IN_PROGRESS = 1 << 1;

    /**
     * Flag: A timeout occurred while waiting for web kit to process this input event.
     */
    public static final int FLAG_WEBKIT_TIMEOUT = 1 << 2;

    /**
     * Flag: Indicates that the event was transformed for delivery to web kit.
     * The event must be transformed back before being delivered to the UI.
     */
    public static final int FLAG_WEBKIT_TRANSFORMED_EVENT = 1 << 3;

    public WebViewInputDispatcher(UiCallbacks uiCallbacks, WebKitCallbacks webKitCallbacks) {
        this.mUiCallbacks = uiCallbacks;
        mUiHandler = new UiHandler(uiCallbacks.getUiLooper());

        this.mWebKitCallbacks = webKitCallbacks;
        mWebKitHandler = new WebKitHandler(webKitCallbacks.getWebKitLooper());

        ViewConfiguration config = ViewConfiguration.get(mUiCallbacks.getContext());
        mDoubleTapSlopSquared = config.getScaledDoubleTapSlop();
        mDoubleTapSlopSquared = (mDoubleTapSlopSquared * mDoubleTapSlopSquared);
        mTouchSlopSquared = config.getScaledTouchSlop();
        mTouchSlopSquared = (mTouchSlopSquared * mTouchSlopSquared);
    }

    /**
     * Sets whether web kit wants to receive touch events.
     *
     * @param enable True to enable dispatching of touch events to web kit, otherwise
     * web kit will be skipped.
     */
    public void setWebKitWantsTouchEvents(boolean enable) {
        if (DEBUG) {
            Log.d(TAG, "webkitWantsTouchEvents: " + enable);
        }
        synchronized (mLock) {
            if (mPostSendTouchEventsToWebKit != enable) {
                if (!enable) {
                    enqueueWebKitCancelTouchEventIfNeededLocked();
                }
                mPostSendTouchEventsToWebKit = enable;
            }
        }
    }

    /**
     * Posts a pointer event to the dispatch queue.
     *
     * @param event The event to post.
     * @param webKitXOffset X offset to apply to events before dispatching them to web kit.
     * @param webKitYOffset Y offset to apply to events before dispatching them to web kit.
     * @param webKitScale The scale factor to apply to translated events before dispatching
     * them to web kit.
     * @return True if the dispatcher will handle the event, false if the event is unsupported.
     */
    public boolean postPointerEvent(MotionEvent event,
            int webKitXOffset, int webKitYOffset, float webKitScale) {
        if (event == null) {
            throw new IllegalArgumentException("event cannot be null");
        }

        if (DEBUG) {
            Log.d(TAG, "postPointerEvent: " + event);
        }

        final int action = event.getActionMasked();
        final int eventType;
        switch (action) {
            case MotionEvent.ACTION_DOWN:
            case MotionEvent.ACTION_MOVE:
            case MotionEvent.ACTION_UP:
            case MotionEvent.ACTION_POINTER_DOWN:
            case MotionEvent.ACTION_POINTER_UP:
            case MotionEvent.ACTION_CANCEL:
                eventType = EVENT_TYPE_TOUCH;
                break;
            case MotionEvent.ACTION_SCROLL:
                eventType = EVENT_TYPE_SCROLL;
                break;
            case MotionEvent.ACTION_HOVER_ENTER:
            case MotionEvent.ACTION_HOVER_MOVE:
            case MotionEvent.ACTION_HOVER_EXIT:
                eventType = EVENT_TYPE_HOVER;
                break;
            default:
                return false; // currently unsupported event type
        }

        synchronized (mLock) {
            // Ensure that the event is consistent and should be delivered.
            MotionEvent eventToEnqueue = event;
            if (eventType == EVENT_TYPE_TOUCH) {
                eventToEnqueue = mPostTouchStream.update(event);
                if (eventToEnqueue == null) {
                    if (DEBUG) {
                        Log.d(TAG, "postPointerEvent: dropped event " + event);
                    }
                    unscheduleLongPressLocked();
                    unscheduleClickLocked();
                    return false;
                }

                if (mPostSendTouchEventsToWebKit
                        && mPostDoNotSendTouchEventsToWebKitUntilNextGesture
                        && action == MotionEvent.ACTION_DOWN) {
                    // Recover from a previous web kit timeout.
                    mPostDoNotSendTouchEventsToWebKitUntilNextGesture = false;
                }
            }

            // Copy the event because we need to retain ownership.
            if (eventToEnqueue == event) {
                eventToEnqueue = event.copy();
            }

            DispatchEvent d = obtainDispatchEventLocked(eventToEnqueue, eventType, 0,
                    webKitXOffset, webKitYOffset, webKitScale);
            enqueueEventLocked(d);
        }
        return true;
    }

    private void scheduleLongPressLocked() {
        unscheduleLongPressLocked();
        mPostLongPressScheduled = true;
        mUiHandler.sendEmptyMessageDelayed(UiHandler.MSG_LONG_PRESS,
                LONG_PRESS_TIMEOUT);
    }

    private void unscheduleLongPressLocked() {
        if (mPostLongPressScheduled) {
            mPostLongPressScheduled = false;
            mUiHandler.removeMessages(UiHandler.MSG_LONG_PRESS);
        }
    }

    public boolean shouldShowTapHighlight() {
        synchronized (mLock) {
            return mPostLongPressScheduled || mPostClickScheduled;
        }
    }

    private void postLongPress() {
        synchronized (mLock) {
            if (!mPostLongPressScheduled) {
                return;
            }
            mPostLongPressScheduled = false;

            MotionEvent event = mPostTouchStream.getLastEvent();
            if (event == null) {
                return;
            }

            switch (event.getActionMasked()) {
                case MotionEvent.ACTION_DOWN:
                case MotionEvent.ACTION_MOVE:
                case MotionEvent.ACTION_POINTER_DOWN:
                case MotionEvent.ACTION_POINTER_UP:
                    break;
                default:
                    return;
            }

            MotionEvent eventToEnqueue = MotionEvent.obtainNoHistory(event);
            eventToEnqueue.setAction(MotionEvent.ACTION_MOVE);
            DispatchEvent d = obtainDispatchEventLocked(eventToEnqueue, EVENT_TYPE_LONG_PRESS, 0,
                    mPostLastWebKitXOffset, mPostLastWebKitYOffset, mPostLastWebKitScale);
            enqueueEventLocked(d);
        }
    }

    private void scheduleClickLocked() {
        unscheduleClickLocked();
        mPostClickScheduled = true;
        mUiHandler.sendEmptyMessageDelayed(UiHandler.MSG_CLICK, DOUBLE_TAP_TIMEOUT);
    }

    private void unscheduleClickLocked() {
        if (mPostClickScheduled) {
            mPostClickScheduled = false;
            mUiHandler.removeMessages(UiHandler.MSG_CLICK);
        }
    }

    private void postClick() {
        synchronized (mLock) {
            if (!mPostClickScheduled) {
                return;
            }
            mPostClickScheduled = false;

            MotionEvent event = mPostTouchStream.getLastEvent();
            if (event == null || event.getAction() != MotionEvent.ACTION_UP) {
                return;
            }

            MotionEvent eventToEnqueue = MotionEvent.obtainNoHistory(event);
            DispatchEvent d = obtainDispatchEventLocked(eventToEnqueue, EVENT_TYPE_CLICK, 0,
                    mPostLastWebKitXOffset, mPostLastWebKitYOffset, mPostLastWebKitScale);
            enqueueEventLocked(d);
        }
    }

    private void checkForDoubleTapOnDownLocked(MotionEvent event) {
        mIsDoubleTapCandidate = false;
        if (!mPostClickScheduled) {
            return;
        }
        int deltaX = (int) mInitialDownX - (int) event.getX();
        int deltaY = (int) mInitialDownY - (int) event.getY();
        if ((deltaX * deltaX + deltaY * deltaY) < mDoubleTapSlopSquared) {
            unscheduleClickLocked();
            mIsDoubleTapCandidate = true;
        }
    }

    private boolean isClickCandidateLocked(MotionEvent event) {
        if (event == null
                || event.getActionMasked() != MotionEvent.ACTION_UP
                || !mIsTapCandidate) {
            return false;
        }
        long downDuration = event.getEventTime() - event.getDownTime();
        return downDuration < LONG_PRESS_TIMEOUT;
    }

    private void enqueueDoubleTapLocked(MotionEvent event) {
        unscheduleClickLocked();
        MotionEvent eventToEnqueue = MotionEvent.obtainNoHistory(event);
        DispatchEvent d = obtainDispatchEventLocked(eventToEnqueue, EVENT_TYPE_DOUBLE_TAP, 0,
                mPostLastWebKitXOffset, mPostLastWebKitYOffset, mPostLastWebKitScale);
        enqueueEventLocked(d);
        mIsDoubleTapCandidate = false;
    }

    private void checkForSlopLocked(MotionEvent event) {
        if (!mIsTapCandidate) {
            return;
        }
        int deltaX = (int) mInitialDownX - (int) event.getX();
        int deltaY = (int) mInitialDownY - (int) event.getY();
        if ((deltaX * deltaX + deltaY * deltaY) > mTouchSlopSquared) {
            unscheduleLongPressLocked();
            mIsTapCandidate = false;
        }
    }

    private void updateStateTrackersLocked(DispatchEvent d, MotionEvent event) {
        mPostLastWebKitXOffset = d.mWebKitXOffset;
        mPostLastWebKitYOffset = d.mWebKitYOffset;
        mPostLastWebKitScale = d.mWebKitScale;
        int action = event != null ? event.getAction() : MotionEvent.ACTION_CANCEL;
        if (d.mEventType != EVENT_TYPE_TOUCH) {
            return;
        }

        if (action == MotionEvent.ACTION_CANCEL
                || event.getPointerCount() > 1) {
            unscheduleLongPressLocked();
            unscheduleClickLocked();
            mIsDoubleTapCandidate = false;
            mIsTapCandidate = false;
        } else if (action == MotionEvent.ACTION_DOWN) {
            checkForDoubleTapOnDownLocked(event);
            scheduleLongPressLocked();
            mIsTapCandidate = true;
            mInitialDownX = event.getX();
            mInitialDownY = event.getY();
        } else if (action == MotionEvent.ACTION_UP) {
            unscheduleLongPressLocked();
            if (isClickCandidateLocked(event)) {
                if (mIsDoubleTapCandidate) {
                    enqueueDoubleTapLocked(event);
                } else {
                    scheduleClickLocked();
                }
            }
        } else if (action == MotionEvent.ACTION_MOVE) {
            checkForSlopLocked(event);
        }
    }

    /**
     * Dispatches pending web kit events.
     * Must only be called from the web kit thread.
     *
     * This method may be used to flush the queue of pending input events
     * immediately.  This method may help to reduce input dispatch latency
     * if called before certain expensive operations such as drawing.
     */
    public void dispatchWebKitEvents() {
        dispatchWebKitEvents(false);
    }

    private void dispatchWebKitEvents(boolean calledFromHandler) {
        for (;;) {
            // Get the next event, but leave it in the queue so we can move it to the UI
            // queue if a timeout occurs.
            DispatchEvent d;
            MotionEvent event;
            final int eventType;
            int flags;
            synchronized (mLock) {
                if (!ENABLE_EVENT_BATCHING) {
                    drainStaleWebKitEventsLocked();
                }
                d = mWebKitDispatchEventQueue.mHead;
                if (d == null) {
                    if (mWebKitDispatchScheduled) {
                        mWebKitDispatchScheduled = false;
                        if (!calledFromHandler) {
                            mWebKitHandler.removeMessages(
                                    WebKitHandler.MSG_DISPATCH_WEBKIT_EVENTS);
                        }
                    }
                    return;
                }

                event = d.mEvent;
                if (event != null) {
                    event.offsetLocation(d.mWebKitXOffset, d.mWebKitYOffset);
                    event.scale(d.mWebKitScale);
                    d.mFlags |= FLAG_WEBKIT_TRANSFORMED_EVENT;
                }

                eventType = d.mEventType;
                if (eventType == EVENT_TYPE_TOUCH) {
                    event = mWebKitTouchStream.update(event);
                    if (DEBUG && event == null && d.mEvent != null) {
                        Log.d(TAG, "dispatchWebKitEvents: dropped event " + d.mEvent);
                    }
                }

                d.mFlags |= FLAG_WEBKIT_IN_PROGRESS;
                flags = d.mFlags;
            }

            // Handle the event.
            final boolean preventDefault;
            if (event == null) {
                preventDefault = false;
            } else {
                preventDefault = dispatchWebKitEvent(event, eventType, flags);
            }

            synchronized (mLock) {
                flags = d.mFlags;
                d.mFlags = flags & ~FLAG_WEBKIT_IN_PROGRESS;
                boolean recycleEvent = event != d.mEvent;

                if ((flags & FLAG_WEBKIT_TIMEOUT) != 0) {
                    // A timeout occurred!
                    recycleDispatchEventLocked(d);
                } else {
                    // Web kit finished in a timely manner.  Dequeue the event.
                    assert mWebKitDispatchEventQueue.mHead == d;
                    mWebKitDispatchEventQueue.dequeue();

                    updateWebKitTimeoutLocked();

                    if ((flags & FLAG_PRIVATE) != 0) {
                        // Event was intended for web kit only.  All done.
                        recycleDispatchEventLocked(d);
                    } else if (preventDefault) {
                        // Web kit has decided to consume the event!
                        if (d.mEventType == EVENT_TYPE_TOUCH) {
                            enqueueUiCancelTouchEventIfNeededLocked();
                        }
                    } else {
                        // Web kit is being friendly.  Pass the event to the UI.
                        enqueueUiEventUnbatchedLocked(d);
                    }
                }

                if (event != null && recycleEvent) {
                    event.recycle();
                }
            }
        }
    }

    // Runs on web kit thread.
    private boolean dispatchWebKitEvent(MotionEvent event, int eventType, int flags) {
        if (DEBUG) {
            Log.d(TAG, "dispatchWebKitEvent: event=" + event
                    + ", eventType=" + eventType + ", flags=" + flags);
        }
        boolean preventDefault = mWebKitCallbacks.dispatchWebKitEvent(
                event, eventType, flags);
        if (DEBUG) {
            Log.d(TAG, "dispatchWebKitEvent: preventDefault=" + preventDefault);
        }
        return preventDefault;
    }

    private boolean isMoveEventLocked(DispatchEvent d) {
        return d.mEvent != null
                && d.mEvent.getActionMasked() == MotionEvent.ACTION_MOVE;
    }

    private void drainStaleWebKitEventsLocked() {
        DispatchEvent d = mWebKitDispatchEventQueue.mHead;
        while (d != null && d.mNext != null
                && isMoveEventLocked(d)
                && isMoveEventLocked(d.mNext)) {
            DispatchEvent next = d.mNext;
            skipWebKitEventLocked(d);
            d = next;
        }
        mWebKitDispatchEventQueue.mHead = d;
    }

    // Runs on UI thread in response to the web kit thread appearing to be unresponsive.
    private void handleWebKitTimeout() {
        synchronized (mLock) {
            if (!mWebKitTimeoutScheduled) {
                return;
            }
            mWebKitTimeoutScheduled = false;

            if (DEBUG) {
                Log.d(TAG, "handleWebKitTimeout: timeout occurred!");
            }

            // Drain the web kit event queue.
            DispatchEvent d = mWebKitDispatchEventQueue.dequeueList();

            // If web kit was processing an event (must be at the head of the list because
            // it can only do one at a time), then clone it or ignore it.
            if ((d.mFlags & FLAG_WEBKIT_IN_PROGRESS) != 0) {
                d.mFlags |= FLAG_WEBKIT_TIMEOUT;
                if ((d.mFlags & FLAG_PRIVATE) != 0) {
                    d = d.mNext; // the event is private to web kit, ignore it
                } else {
                    d = copyDispatchEventLocked(d);
                    d.mFlags &= ~FLAG_WEBKIT_IN_PROGRESS;
                }
            }

            // Enqueue all non-private events for handling by the UI thread.
            while (d != null) {
                DispatchEvent next = d.mNext;
                skipWebKitEventLocked(d);
                d = next;
            }

            // Tell web kit to cancel all pending touches.
            // This also prevents us from sending web kit any more touches until the
            // next gesture begins.  (As required to ensure touch event stream consistency.)
            enqueueWebKitCancelTouchEventIfNeededLocked();
        }
    }

    private void skipWebKitEventLocked(DispatchEvent d) {
        d.mNext = null;
        if ((d.mFlags & FLAG_PRIVATE) != 0) {
            recycleDispatchEventLocked(d);
        } else {
            d.mFlags |= FLAG_WEBKIT_TIMEOUT;
            enqueueUiEventUnbatchedLocked(d);
        }
    }

    /**
     * Dispatches pending UI events.
     * Must only be called from the UI thread.
     *
     * This method may be used to flush the queue of pending input events
     * immediately.  This method may help to reduce input dispatch latency
     * if called before certain expensive operations such as drawing.
     */
    public void dispatchUiEvents() {
        dispatchUiEvents(false);
    }

    private void dispatchUiEvents(boolean calledFromHandler) {
        for (;;) {
            MotionEvent event;
            final int eventType;
            final int flags;
            synchronized (mLock) {
                DispatchEvent d = mUiDispatchEventQueue.dequeue();
                if (d == null) {
                    if (mUiDispatchScheduled) {
                        mUiDispatchScheduled = false;
                        if (!calledFromHandler) {
                            mUiHandler.removeMessages(UiHandler.MSG_DISPATCH_UI_EVENTS);
                        }
                    }
                    return;
                }

                event = d.mEvent;
                if (event != null && (d.mFlags & FLAG_WEBKIT_TRANSFORMED_EVENT) != 0) {
                    event.scale(1.0f / d.mWebKitScale);
                    event.offsetLocation(-d.mWebKitXOffset, -d.mWebKitYOffset);
                    d.mFlags &= ~FLAG_WEBKIT_TRANSFORMED_EVENT;
                }

                eventType = d.mEventType;
                if (eventType == EVENT_TYPE_TOUCH) {
                    event = mUiTouchStream.update(event);
                    if (DEBUG && event == null && d.mEvent != null) {
                        Log.d(TAG, "dispatchUiEvents: dropped event " + d.mEvent);
                    }
                }

                flags = d.mFlags;

                updateStateTrackersLocked(d, event);
                if (event == d.mEvent) {
                    d.mEvent = null; // retain ownership of event, don't recycle it yet
                }
                recycleDispatchEventLocked(d);
            }

            // Handle the event.
            if (event != null) {
                dispatchUiEvent(event, eventType, flags);
                event.recycle();
            }
        }
    }

    // Runs on UI thread.
    private void dispatchUiEvent(MotionEvent event, int eventType, int flags) {
        if (DEBUG) {
            Log.d(TAG, "dispatchUiEvent: event=" + event
                    + ", eventType=" + eventType + ", flags=" + flags);
        }
        mUiCallbacks.dispatchUiEvent(event, eventType, flags);
    }

    private void enqueueEventLocked(DispatchEvent d) {
        if (!shouldSkipWebKit(d.mEventType)) {
            enqueueWebKitEventLocked(d);
        } else {
            enqueueUiEventLocked(d);
        }
    }

    private boolean shouldSkipWebKit(int eventType) {
        switch (eventType) {
            case EVENT_TYPE_CLICK:
            case EVENT_TYPE_HOVER:
            case EVENT_TYPE_SCROLL:
                return false;
            case EVENT_TYPE_TOUCH:
                return !mPostSendTouchEventsToWebKit
                        || mPostDoNotSendTouchEventsToWebKitUntilNextGesture;
        }
        return true;
    }

    private void enqueueWebKitCancelTouchEventIfNeededLocked() {
        // We want to cancel touch events that were delivered to web kit.
        // Enqueue a null event at the end of the queue if needed.
        if (mWebKitTouchStream.isCancelNeeded() || !mWebKitDispatchEventQueue.isEmpty()) {
            DispatchEvent d = obtainDispatchEventLocked(null, EVENT_TYPE_TOUCH, FLAG_PRIVATE,
                    0, 0, 1.0f);
            enqueueWebKitEventUnbatchedLocked(d);
            mPostDoNotSendTouchEventsToWebKitUntilNextGesture = true;
        }
    }

    private void enqueueWebKitEventLocked(DispatchEvent d) {
        if (batchEventLocked(d, mWebKitDispatchEventQueue.mTail)) {
            if (DEBUG) {
                Log.d(TAG, "enqueueWebKitEventLocked: batched event " + d.mEvent);
            }
            recycleDispatchEventLocked(d);
        } else {
            enqueueWebKitEventUnbatchedLocked(d);
        }
    }

    private void enqueueWebKitEventUnbatchedLocked(DispatchEvent d) {
        if (DEBUG) {
            Log.d(TAG, "enqueueWebKitEventUnbatchedLocked: enqueued event " + d.mEvent);
        }
        mWebKitDispatchEventQueue.enqueue(d);
        scheduleWebKitDispatchLocked();
        updateWebKitTimeoutLocked();
    }

    private void scheduleWebKitDispatchLocked() {
        if (!mWebKitDispatchScheduled) {
            mWebKitHandler.sendEmptyMessage(WebKitHandler.MSG_DISPATCH_WEBKIT_EVENTS);
            mWebKitDispatchScheduled = true;
        }
    }

    private void updateWebKitTimeoutLocked() {
        DispatchEvent d = mWebKitDispatchEventQueue.mHead;
        if (d != null && mWebKitTimeoutScheduled && mWebKitTimeoutTime == d.mTimeoutTime) {
            return;
        }
        if (mWebKitTimeoutScheduled) {
            mUiHandler.removeMessages(UiHandler.MSG_WEBKIT_TIMEOUT);
            mWebKitTimeoutScheduled = false;
        }
        if (d != null) {
            mUiHandler.sendEmptyMessageAtTime(UiHandler.MSG_WEBKIT_TIMEOUT, d.mTimeoutTime);
            mWebKitTimeoutScheduled = true;
            mWebKitTimeoutTime = d.mTimeoutTime;
        }
    }

    private void enqueueUiCancelTouchEventIfNeededLocked() {
        // We want to cancel touch events that were delivered to the UI.
        // Enqueue a null event at the end of the queue if needed.
        if (mUiTouchStream.isCancelNeeded() || !mUiDispatchEventQueue.isEmpty()) {
            DispatchEvent d = obtainDispatchEventLocked(null, EVENT_TYPE_TOUCH, FLAG_PRIVATE,
                    0, 0, 1.0f);
            enqueueUiEventUnbatchedLocked(d);
        }
    }

    private void enqueueUiEventLocked(DispatchEvent d) {
        if (batchEventLocked(d, mUiDispatchEventQueue.mTail)) {
            if (DEBUG) {
                Log.d(TAG, "enqueueUiEventLocked: batched event " + d.mEvent);
            }
            recycleDispatchEventLocked(d);
        } else {
            enqueueUiEventUnbatchedLocked(d);
        }
    }

    private void enqueueUiEventUnbatchedLocked(DispatchEvent d) {
        if (DEBUG) {
            Log.d(TAG, "enqueueUiEventUnbatchedLocked: enqueued event " + d.mEvent);
        }
        mUiDispatchEventQueue.enqueue(d);
        scheduleUiDispatchLocked();
    }

    private void scheduleUiDispatchLocked() {
        if (!mUiDispatchScheduled) {
            mUiHandler.sendEmptyMessage(UiHandler.MSG_DISPATCH_UI_EVENTS);
            mUiDispatchScheduled = true;
        }
    }

    private boolean batchEventLocked(DispatchEvent in, DispatchEvent tail) {
        if (!ENABLE_EVENT_BATCHING) {
            return false;
        }
        if (tail != null && tail.mEvent != null && in.mEvent != null
                && in.mEventType == tail.mEventType
                && in.mFlags == tail.mFlags
                && in.mWebKitXOffset == tail.mWebKitXOffset
                && in.mWebKitYOffset == tail.mWebKitYOffset
                && in.mWebKitScale == tail.mWebKitScale) {
            return tail.mEvent.addBatch(in.mEvent);
        }
        return false;
    }

    private DispatchEvent obtainDispatchEventLocked(MotionEvent event,
            int eventType, int flags, int webKitXOffset, int webKitYOffset, float webKitScale) {
        DispatchEvent d = obtainUninitializedDispatchEventLocked();
        d.mEvent = event;
        d.mEventType = eventType;
        d.mFlags = flags;
        d.mTimeoutTime = SystemClock.uptimeMillis() + WEBKIT_TIMEOUT_MILLIS;
        d.mWebKitXOffset = webKitXOffset;
        d.mWebKitYOffset = webKitYOffset;
        d.mWebKitScale = webKitScale;
        if (DEBUG) {
            Log.d(TAG, "Timeout time: " + (d.mTimeoutTime - SystemClock.uptimeMillis()));
        }
        return d;
    }

    private DispatchEvent copyDispatchEventLocked(DispatchEvent d) {
        DispatchEvent copy = obtainUninitializedDispatchEventLocked();
        if (d.mEvent != null) {
            copy.mEvent = d.mEvent.copy();
        }
        copy.mEventType = d.mEventType;
        copy.mFlags = d.mFlags;
        copy.mTimeoutTime = d.mTimeoutTime;
        copy.mWebKitXOffset = d.mWebKitXOffset;
        copy.mWebKitYOffset = d.mWebKitYOffset;
        copy.mWebKitScale = d.mWebKitScale;
        copy.mNext = d.mNext;
        return copy;
    }

    private DispatchEvent obtainUninitializedDispatchEventLocked() {
        DispatchEvent d = mDispatchEventPool;
        if (d != null) {
            mDispatchEventPoolSize -= 1;
            mDispatchEventPool = d.mNext;
            d.mNext = null;
        } else {
            d = new DispatchEvent();
        }
        return d;
    }

    private void recycleDispatchEventLocked(DispatchEvent d) {
        if (d.mEvent != null) {
            d.mEvent.recycle();
            d.mEvent = null;
        }

        if (mDispatchEventPoolSize < MAX_DISPATCH_EVENT_POOL_SIZE) {
            mDispatchEventPoolSize += 1;
            d.mNext = mDispatchEventPool;
            mDispatchEventPool = d;
        }
    }

    /* Implemented by {@link WebViewClassic} to perform operations on the UI thread. */
    public static interface UiCallbacks {
        /**
         * Gets the UI thread's looper.
         * @return The looper.
         */
        public Looper getUiLooper();

        /**
         * Gets the UI's context
         * @return The context
         */
        public Context getContext();

        /**
         * Dispatches an event to the UI.
         * @param event The event.
         * @param eventType The event type.
         * @param flags The event's dispatch flags.
         */
        public void dispatchUiEvent(MotionEvent event, int eventType, int flags);
    }

    /* Implemented by {@link WebViewCore} to perform operations on the web kit thread. */
    public static interface WebKitCallbacks {
        /**
         * Gets the web kit thread's looper.
         * @return The looper.
         */
        public Looper getWebKitLooper();

        /**
         * Dispatches an event to web kit.
         * @param event The event.
         * @param eventType The event type.
         * @param flags The event's dispatch flags.
         * @return True if web kit wants to prevent default event handling.
         */
        public boolean dispatchWebKitEvent(MotionEvent event, int eventType, int flags);
    }

    // Runs on UI thread.
    private final class UiHandler extends Handler {
        public static final int MSG_DISPATCH_UI_EVENTS = 1;
        public static final int MSG_WEBKIT_TIMEOUT = 2;
        public static final int MSG_LONG_PRESS = 3;
        public static final int MSG_CLICK = 4;

        public UiHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_DISPATCH_UI_EVENTS:
                    dispatchUiEvents(true);
                    break;
                case MSG_WEBKIT_TIMEOUT:
                    handleWebKitTimeout();
                    break;
                case MSG_LONG_PRESS:
                    postLongPress();
                    break;
                case MSG_CLICK:
                    postClick();
                    break;
                default:
                    throw new IllegalStateException("Unknown message type: " + msg.what);
            }
        }
    }

    // Runs on web kit thread.
    private final class WebKitHandler extends Handler {
        public static final int MSG_DISPATCH_WEBKIT_EVENTS = 1;

        public WebKitHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_DISPATCH_WEBKIT_EVENTS:
                    dispatchWebKitEvents(true);
                    break;
                default:
                    throw new IllegalStateException("Unknown message type: " + msg.what);
            }
        }
    }

    private static final class DispatchEvent {
        public DispatchEvent mNext;

        public MotionEvent mEvent;
        public int mEventType;
        public int mFlags;
        public long mTimeoutTime;
        public int mWebKitXOffset;
        public int mWebKitYOffset;
        public float mWebKitScale;
    }

    private static final class DispatchEventQueue {
        public DispatchEvent mHead;
        public DispatchEvent mTail;

        public boolean isEmpty() {
            return mHead != null;
        }

        public void enqueue(DispatchEvent d) {
            if (mHead == null) {
                mHead = d;
                mTail = d;
            } else {
                mTail.mNext = d;
                mTail = d;
            }
        }

        public DispatchEvent dequeue() {
            DispatchEvent d = mHead;
            if (d != null) {
                DispatchEvent next = d.mNext;
                if (next == null) {
                    mHead = null;
                    mTail = null;
                } else {
                    mHead = next;
                    d.mNext = null;
                }
            }
            return d;
        }

        public DispatchEvent dequeueList() {
            DispatchEvent d = mHead;
            if (d != null) {
                mHead = null;
                mTail = null;
            }
            return d;
        }
    }

    /**
     * Keeps track of a stream of touch events so that we can discard touch
     * events that would make the stream inconsistent.
     */
    private static final class TouchStream {
        private MotionEvent mLastEvent;

        /**
         * Gets the last touch event that was delivered.
         * @return The last touch event, or null if none.
         */
        public MotionEvent getLastEvent() {
            return mLastEvent;
        }

        /**
         * Updates the touch event stream.
         * @param event The event that we intend to send, or null to cancel the
         * touch event stream.
         * @return The event that we should actually send, or null if no event should
         * be sent because the proposed event would make the stream inconsistent.
         */
        public MotionEvent update(MotionEvent event) {
            if (event == null) {
                if (isCancelNeeded()) {
                    event = mLastEvent;
                    if (event != null) {
                        event.setAction(MotionEvent.ACTION_CANCEL);
                        mLastEvent = null;
                    }
                }
                return event;
            }

            switch (event.getActionMasked()) {
                case MotionEvent.ACTION_MOVE:
                case MotionEvent.ACTION_UP:
                case MotionEvent.ACTION_POINTER_DOWN:
                case MotionEvent.ACTION_POINTER_UP:
                    if (mLastEvent == null
                            || mLastEvent.getAction() == MotionEvent.ACTION_UP) {
                        return null;
                    }
                    updateLastEvent(event);
                    return event;

                case MotionEvent.ACTION_DOWN:
                    updateLastEvent(event);
                    return event;

                case MotionEvent.ACTION_CANCEL:
                    if (mLastEvent == null) {
                        return null;
                    }
                    updateLastEvent(null);
                    return event;

                default:
                    return null;
            }
        }

        /**
         * Returns true if there is a gesture in progress that may need to be canceled.
         * @return True if cancel is needed.
         */
        public boolean isCancelNeeded() {
            return mLastEvent != null && mLastEvent.getAction() != MotionEvent.ACTION_UP;
        }

        private void updateLastEvent(MotionEvent event) {
            if (mLastEvent != null) {
                mLastEvent.recycle();
            }
            mLastEvent = event != null ? MotionEvent.obtainNoHistory(event) : null;
        }
    }
}