/*
* 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.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 boolean mPostShowTapHighlightScheduled;
private boolean mPostHideTapHighlightScheduled;
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();
private static final int PRESSED_STATE_DURATION = ViewConfiguration.getPressedStateDuration();
/**
* 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;
/**
* Event type: Indicates that a hit test should be performed
*/
public static final int EVENT_TYPE_HIT_TEST = 6;
/**
* 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();
hideTapCandidateLocked();
return false;
}
if (action == MotionEvent.ACTION_DOWN && mPostSendTouchEventsToWebKit) {
if (mUiCallbacks.shouldInterceptTouchEvent(eventToEnqueue)) {
mPostDoNotSendTouchEventsToWebKitUntilNextGesture = true;
} else if (mPostDoNotSendTouchEventsToWebKitUntilNextGesture) {
// 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);
updateStateTrackersLocked(d, event);
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);
}
}
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 hideTapCandidateLocked() {
unscheduleHideTapHighlightLocked();
unscheduleShowTapHighlightLocked();
mUiCallbacks.showTapHighlight(false);
}
private void showTapCandidateLocked() {
unscheduleHideTapHighlightLocked();
unscheduleShowTapHighlightLocked();
mUiCallbacks.showTapHighlight(true);
}
private void scheduleShowTapHighlightLocked() {
unscheduleShowTapHighlightLocked();
mPostShowTapHighlightScheduled = true;
mUiHandler.sendEmptyMessageDelayed(UiHandler.MSG_SHOW_TAP_HIGHLIGHT,
TAP_TIMEOUT);
}
private void unscheduleShowTapHighlightLocked() {
if (mPostShowTapHighlightScheduled) {
mPostShowTapHighlightScheduled = false;
mUiHandler.removeMessages(UiHandler.MSG_SHOW_TAP_HIGHLIGHT);
}
}
private void scheduleHideTapHighlightLocked() {
unscheduleHideTapHighlightLocked();
mPostHideTapHighlightScheduled = true;
mUiHandler.sendEmptyMessageDelayed(UiHandler.MSG_HIDE_TAP_HIGHLIGHT,
PRESSED_STATE_DURATION);
}
private void unscheduleHideTapHighlightLocked() {
if (mPostHideTapHighlightScheduled) {
mPostHideTapHighlightScheduled = false;
mUiHandler.removeMessages(UiHandler.MSG_HIDE_TAP_HIGHLIGHT);
}
}
private void postShowTapHighlight(boolean show) {
synchronized (mLock) {
if (show) {
if (!mPostShowTapHighlightScheduled) {
return;
}
mPostShowTapHighlightScheduled = false;
} else {
if (!mPostHideTapHighlightScheduled) {
return;
}
mPostHideTapHighlightScheduled = false;
}
mUiCallbacks.showTapHighlight(show);
}
}
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;
}
showTapCandidateLocked();
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) {
MotionEvent eventToEnqueue = MotionEvent.obtainNoHistory(event);
DispatchEvent d = obtainDispatchEventLocked(eventToEnqueue, EVENT_TYPE_DOUBLE_TAP, 0,
mPostLastWebKitXOffset, mPostLastWebKitYOffset, mPostLastWebKitScale);
enqueueEventLocked(d);
}
private void enqueueHitTestLocked(MotionEvent event) {
mUiCallbacks.clearPreviousHitTest();
MotionEvent eventToEnqueue = MotionEvent.obtainNoHistory(event);
DispatchEvent d = obtainDispatchEventLocked(eventToEnqueue, EVENT_TYPE_HIT_TEST, 0,
mPostLastWebKitXOffset, mPostLastWebKitYOffset, mPostLastWebKitScale);
enqueueEventLocked(d);
}
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;
hideTapCandidateLocked();
}
}
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();
hideTapCandidateLocked();
mIsDoubleTapCandidate = false;
mIsTapCandidate = false;
hideTapCandidateLocked();
} else if (action == MotionEvent.ACTION_DOWN) {
checkForDoubleTapOnDownLocked(event);
scheduleLongPressLocked();
mIsTapCandidate = true;
mInitialDownX = event.getX();
mInitialDownY = event.getY();
enqueueHitTestLocked(event);
if (mIsDoubleTapCandidate) {
hideTapCandidateLocked();
} else {
scheduleShowTapHighlightLocked();
}
} else if (action == MotionEvent.ACTION_UP) {
unscheduleLongPressLocked();
if (isClickCandidateLocked(event)) {
if (mIsDoubleTapCandidate) {
hideTapCandidateLocked();
enqueueDoubleTapLocked(event);
} else {
scheduleClickLocked();
}
} else {
hideTapCandidateLocked();
}
} 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();
unscheduleLongPressLocked();
}
} else {
// Web kit is being friendly. Pass the event to the UI.
enqueueUiEventUnbatchedLocked(d);
}
}
if (event != null && recycleEvent) {
event.recycle();
}
if (eventType == EVENT_TYPE_CLICK) {
scheduleHideTapHighlightLocked();
}
}
}
}
// 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(
this, 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;
}
// Called by WebKit when it doesn't care about the rest of the touch stream
public void skipWebkitForRemainingTouchStream() {
// Just treat this like a timeout
handleWebKitTimeout();
}
// 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;
if (event == d.mEvent) {
d.mEvent = null; // retain ownership of event, don't recycle it yet
}
recycleDispatchEventLocked(d);
if (eventType == EVENT_TYPE_CLICK) {
scheduleHideTapHighlightLocked();
}
}
// 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)) {
enqueueWebKitEventLocked(d);
} else {
enqueueUiEventLocked(d);
}
}
private boolean shouldSkipWebKit(DispatchEvent d) {
switch (d.mEventType) {
case EVENT_TYPE_CLICK:
case EVENT_TYPE_HOVER:
case EVENT_TYPE_SCROLL:
case EVENT_TYPE_HIT_TEST:
return false;
case EVENT_TYPE_TOUCH:
// TODO: This should be cleaned up. We now have WebViewInputDispatcher
// and WebViewClassic both checking for slop and doing their own
// thing - they should be consolidated. And by consolidated, I mean
// WebViewClassic's version should just be deleted.
// The reason this is done is because webpages seem to expect
// that they only get an ontouchmove if the slop has been exceeded.
if (mIsTapCandidate && d.mEvent != null
&& d.mEvent.getActionMasked() == MotionEvent.ACTION_MOVE) {
return true;
}
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);
/**
* Asks the UI thread whether this touch event stream should be
* intercepted based on the touch down event.
* @param event The touch down event.
* @return true if the UI stream wants the touch stream without going
* through webkit or false otherwise.
*/
public boolean shouldInterceptTouchEvent(MotionEvent event);
/**
* Inform's the UI that it should show the tap highlight
* @param show True if it should show the highlight, false if it should hide it
*/
public void showTapHighlight(boolean show);
/**
* Called when we are sending a new EVENT_TYPE_HIT_TEST to WebKit, so
* previous hit tests should be cleared as they are obsolete.
*/
public void clearPreviousHitTest();
}
/* 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 dispatcher The WebViewInputDispatcher sending the event
* @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(WebViewInputDispatcher dispatcher,
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 static final int MSG_SHOW_TAP_HIGHLIGHT = 5;
public static final int MSG_HIDE_TAP_HIGHLIGHT = 6;
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;
case MSG_SHOW_TAP_HIGHLIGHT:
postShowTapHighlight(true);
break;
case MSG_HIDE_TAP_HIGHLIGHT:
postShowTapHighlight(false);
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;
}
}
}