在开发过程中,我们经常遇到事件冲突现象,但是很多开发者不知道如何处理。在这里我认为只有认识View 事件的分发机制后,才会懂得如何下手,并且可以处理任何的事件冲突的现象。
一、三个方法
dispatchTouchEvent(MotionEvent ev)
该方法用于进行事件分发。如果事件能够传递给当前View,那么此方法一定会被调用,返回结果受当前View的onTouchEvent和下级的View的dispatchTouchEvent方法的影响,表示是否消耗当前事件
onInterceptTouchEvent(MotionEvent event)
该方法用于拦截事件。如果当前的View成功拦截来某个事件,那么在同一个事件序列当中,此方法将不会再次调用,返回结果表示是否拦截当前事件
onTouchEvent(MotionEvent event)
该方法用于处理事件,返回结果表示是否消耗当前事件,如果不消耗,则在同一个事件序列中,当前View无法再次接收事件。
二、三个方法联系
public boolean dispatchTouchEvent(MotionEvent ev){
boolean consume=false;
if(onInterceptToucEvent(ev)){
consume=onTouchEvent(ev);
}else{
consume=child.dispatchTouchEvent(ev);
}
return consume;
}
对于一个根ViewGroup来说,点击事件产生后,首先会传递给它,这是它的dispatchTouchEvent方法会被调用,如果这个ViewGroup的onInterceptTouchEvent方法返回true就表示它要拦截当前事件,接着这个事件交给这个ViewGroup处理,即它的onTouchEvent方法会被调用,并且这个序列事件都会交给它处理,onInterceptTouchEvent方法不再调用,成功拦截只调用一次。如果这个ViewGroup的onInterceptTouchEvent方法返回false,就表示它不拦截当前事件,这个当前事件就会继续传递给它的子元素,接着子元素的dispatchTouchEvent方法就会被调用,此法反复直到事件被最终处理
三、分析
当一个View需要处理事件时,如果它设置来OnTouchListener,那么OnTouchListener中的onTouch方法会被回调,这时事件如何处理还要看onTouch方法的返回值,如果返回false,则当前View的onTouchEvent方法,如果返回true,那么onTouchEvent方法将不会再调用,由此可见,给View设置onTouchListener,其优先级比onTouchEvent方法高。在onTouchEvent方法中,如果当前设置了OnClickListener方法,那么它的onClick方法将被调用,由此可见,OnClickListener方法在三个优先级中表现为最低。
当一个点击事件产生后,它的传递过程顺序如下:Activity–>Window–>View,所以最先收到事件的是Activity,Activity再传输给Window,最后Window再传输给顶级View,也就是DecorView,顶级View收到事件后,就会按照事件分发机制去分发事件。如果在分发过程中,有个View消耗掉来该事件,那么该View的父容器不再调用调用onTouchEvent方法,除非父容器实现来事件的成功拦截。
四、详细分析
- 同一个事件序列是指从手指接触屏幕的那一刻起,到手指离开屏幕的那一刻结束,在这个过程中所产生的一系列事件,这个事件序列以down事件开始,中间含有数量不定的move事件,最终以up事件结束。
- 正常情况下,一个事件序列只能被一个view拦截且消耗。因为一旦一个元素拦截了某个事件后,那么同一个事件序列内的所有事件都会直接交给它处理,因此同一个事件序列中的事件不能分别由两个View同时处理,但是通过某个特殊手段可以做到,比如一个View将本该自己处理的事件通过onTouchEvent强行传递给其他View处理
- 某个View一旦决定拦截,那么这一个事件序列都只能由它来处理(如果事件序列能够传递给它的话)并且它的onInterceptTouchEvent不会再次调用,也就是说当一个View决定拦截一个事件后,那么系统会把同一个事件序列内的其他方法都直接交给它来处理,因此就不用调用这个View的onInterceptTouchEvent去询问它是否要拦截了。
- 某个View一旦开始处理事件,如果它不消耗ACTION_DOWN事件,即onTouchEvent方法返回false,那么同一事件序列中的其他事件都不会交给它来处理,并且事件将重新交给它的父元素去处理,即父元素的onTouchEvent方法将被调用。也就是说事件一旦交给一个view处理,那么它就鼻息消耗掉,否则同一个事件序列中剩下的事件就不再交给它处理了。
- 如果View不消耗ACTION_DOWN以外的其他事件,那么这个点击事件会消失,此时父元素的onTouchEvent并不会被调用,并且当前的View可以持续收到后续的事件,最终这些消失的点击事件传递给Activity来处理
- ViewGroup默认不拦截任何事件,即onInterceptTouchEvent的返回值的是false
- View没有onInterceptTouchEvent方法,一旦有点击事件,那么它的onTouchEvent方法会被调用
- View的onTouchEvent默认都会消耗事件(返回true),除非它是不可点击(clickable和longclickable
同时为false),View的longclickable的属性默认为false,clickable属性要分情况,比如Button的clickable属性默认为true,而TextView的clickable属性默认值为false - View的enable属性不影响onTouchEvent的默认返回值。只要它的clickable或则longclickable有一个为true,那么它的onTouchEvent就返回true
- onClick会发生的前提是当前的View是可点击的,并且它收到down和up事件
- 事件传递过程是由内到外,即事件总是先传递给父元素,然后在由父元素分发给子元素View,通过requestDisallowInterceptTouchEvent方法可以在子元素中干预父元素的事件分发过程,但是ACTION_DOWN事件除外。
先来看看单一的View类对touch事件的处理
/**
* Pass the touch screen motion event down to the target view, or this
* view if it is the target.
*
* @param event The motion event to be dispatched.
* @return True if the event was handled by the view, false otherwise.
*/
public boolean dispatchTouchEvent(MotionEvent event) {
if (mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onTouchEvent(event, 0);
}
if (onFilterTouchEventForSecurity(event)) { // 一般都成立
//noinspection SimplifiableIfStatement
ListenerInfo li = mListenerInfo;
if (li != null && li.mOnTouchListener != null && (mViewFlags & ENABLED_MASK) == ENABLED
&& li.mOnTouchListener.onTouch(this, event)) { // 先在ENABLED状态下尝试调用onTouch方法
return true; // 如果被onTouch处理了,则直接返回true
}
// 从这里我们可以看出,当你既设置了OnTouchListener又设置了OnClickListener,那么当前者返回true的时候,
// onTouchEvent没机会被调用,当然你的OnClickListener也就不会被触发;另外还有个区别就是onTouch里可以
// 收到每次touch事件,而onClickListener只是在up事件到来时触发。
if (onTouchEvent(event)) {
return true;
}
}
if (mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onUnhandledEvent(event, 0);
}
return false; // 上面的都没处理,则返回false
}
/**
* Implement this method to handle touch screen motion events.
* <p>
* If this method is used to detect click actions, it is recommended that
* the actions be performed by implementing and calling
* {@link #performClick()}. This will ensure consistent system behavior,
* including:
* <ul>
* <li>obeying click sound preferences
* <li>dispatching OnClickListener calls
* <li>handling {@link AccessibilityNodeInfo#ACTION_CLICK ACTION_CLICK} when
* accessibility features are enabled
* </ul>
*
* @param event The motion event.
* @return True if the event was handled, false otherwise.
*/
public boolean onTouchEvent(MotionEvent event) { // View对touch事件的默认处理逻辑
final int viewFlags = mViewFlags;
if ((viewFlags & ENABLED_MASK) == DISABLED) { // DISABLED的状态下
if (event.getAction() == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
setPressed(false); // 复原,如果之前是PRESSED状态
}
// A disabled view that is clickable still consumes the touch
// events, it just doesn't respond to them.
return (((viewFlags & CLICKABLE) == CLICKABLE || // CLICKABLE或LONG_CLICKABLE的view标记为对事件处理了,
(viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)); // 只不过是以do nothing的方式处理了。
}
if (mTouchDelegate != null) {
if (mTouchDelegate.onTouchEvent(event)) { // 如果有TouchDelegate的话,优先交给它处理
return true; // 处理了返回true,否则接着往下走
}
}
if (((viewFlags & CLICKABLE) == CLICKABLE || // View能对touch事件响应的前提要么是CLICKABLE要么是LONG_CLICKABLE
(viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)) {
switch (event.getAction()) {
case MotionEvent.ACTION_UP: // UP事件
// 如果外围有可以滚动的parent的话,当按下时会设置这个标志位
boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;
if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) { // 按下了或者预按下了
// take focus if we don't have it already and we should in
// touch mode.
boolean focusTaken = false;
// 这行代码就是我们上篇博客中说的,设置了FocusableInTouchMode后,View在点击的时候就会
// 尝试requestFocus(),并将focusToken设置为true
if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {
focusTaken = requestFocus(); // 能进来这个if,一般都会返回true
}
if (prepressed) {
// The button is being released before we actually
// showed it as pressed. Make it show the pressed
// state now (before scheduling the click) to ensure
// the user sees it.
// 在前面down事件的时候我们延迟显示view的pressed状态
setPressed(true); // 直到up事件到来的时候才显示pressed状态
}
if (!mHasPerformedLongPress) { // 如果没有长按发生的话
// This is a tap, so remove the longpress check
removeLongPressCallback(); // 移除长按callback
// Only perform take click actions if we were in the pressed state
if (!focusTaken) { // 看到没,focusTaken是false才会进入下面的if语句
// Use a Runnable and post this rather than calling
// performClick directly. This lets other visual state
// of the view update before click actions start.
// 也就是说在touch mode下,不take focus的view第一次点击的时候才会触发onClick事件
if (mPerformClick == null) {
mPerformClick = new PerformClick();
}
if (!post(mPerformClick)) { // 如果post失败了,则直接调用performClick()方法
performClick(); // 这2行代码会触发onClickListener
}
}
}
if (mUnsetPressedState == null) {
mUnsetPressedState = new UnsetPressedState(); // unset按下状态的
}
if (prepressed) {
postDelayed(mUnsetPressedState,
ViewConfiguration.getPressedStateDuration());
} else if (!post(mUnsetPressedState)) {
// If the post failed, unpress right now
mUnsetPressedState.run();
}
removeTapCallback();
}
break;
case MotionEvent.ACTION_DOWN: // DOWN事件
mHasPerformedLongPress = false;
if (performButtonActionOnTouchDown(event)) {
break;
}
// Walk up the hierarchy to determine if we're inside a scrolling container.
boolean isInScrollingContainer = isInScrollingContainer();
// For views inside a scrolling container, delay the pressed feedback for
// a short period in case this is a scroll.
if (isInScrollingContainer) { // 如果是在可以滚动的container里面的话
mPrivateFlags |= PFLAG_PREPRESSED; // 设置PREPRESSED标志位
if (mPendingCheckForTap == null) {
mPendingCheckForTap = new CheckForTap();
} // 延迟pressed feedback
postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
} else {
// Not inside a scrolling container, so show the feedback right away
setPressed(true); // 否则直接显示pressed feedback
checkForLongClick(0); // 并启动长按监测
}
break;
case MotionEvent.ACTION_CANCEL: // 针对CANCEL事件的话,恢复各种状态,移除各种callback
setPressed(false);
removeTapCallback();
removeLongPressCallback();
break;
case MotionEvent.ACTION_MOVE: // MOVE事件
final int x = (int) event.getX();
final int y = (int) event.getY();
// Be lenient about moving outside of buttons
if (!pointInView(x, y, mTouchSlop)) { // 如果移动到view的边界之外了,
// Outside button
removeTapCallback(); // 则取消Tap callback,这样当你松手的时候onClick不会被触发
if ((mPrivateFlags & PFLAG_PRESSED) != 0) { // 当已经是按下状态的话
// Remove any future long press/tap checks
removeLongPressCallback(); // 移除长按callback
setPressed(false); // 恢复按下状态
}
}
break;
}
return true; // 最后返回true,表示对touch事件处理过了,消费了
}
return false; // 既不能单击也不能长按的View,返回false,表示不处理touch事件
}
在开始介绍ViewGroup对touch事件的处理之前,我们还得先看看ViewGroup的一个内部类TouchTarget,因为它描述的就是被
touch的view和touch的手指相关的信息,代码如下:
/* Describes a touched view and the ids of the pointers that it has captured.
*
* This code assumes that pointer ids are always in the range 0..31 such that
* it can use a bitfield to track which pointer ids are present.
* As it happens, the lower layers of the input dispatch pipeline also use the
* same trick so the assumption should be safe here...
*/
private static final class TouchTarget {
private static final int MAX_RECYCLED = 32;
private static final Object sRecycleLock = new Object[0];
private static TouchTarget sRecycleBin; // 回收再利用的链表头
private static int sRecycledCount;
public static final int ALL_POINTER_IDS = -1; // all ones
// The touched child view.
public View child;
// The combined bit mask of pointer ids for all pointers captured by the target.
public int pointerIdBits;
// The next target in the target list.
public TouchTarget next;
private TouchTarget() {
}
// 看到这个有没有很眼熟?是的Message里也有类似的实现,我们在之前介绍Message的文章里详细地分析过
public static TouchTarget obtain(View child, int pointerIdBits) {
final TouchTarget target;
synchronized (sRecycleLock) {
if (sRecycleBin == null) { // 没有可以回收的目标,则new一个返回
target = new TouchTarget();
} else {
target = sRecycleBin; // 重用当前的sRecycleBin
sRecycleBin = target.next; // 更新sRecycleBin指向下一个
sRecycledCount--; // 重用了一个,可回收的减1
target.next = null; // 切断next指向
}
}
target.child = child; // 找到合适的target后,赋值
target.pointerIdBits = pointerIdBits;
return target;
}
public void recycle() { // 基本是obtain的反向过程
synchronized (sRecycleLock) {
if (sRecycledCount < MAX_RECYCLED) {
next = sRecycleBin; // next指向旧的可回收的头
sRecycleBin = this; // update旧的头指向this,表示它自己现在是可回收的target(第一个)
sRecycledCount += 1; // 多了一个可回收的
} else {
next = null; // 没有next了
}
child = null; // 清空child字段
}
}
}
现在开始看看ViewGroup的方法
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
if (mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onTouchEvent(ev, 1);
}
boolean handled = false;
if (onFilterTouchEventForSecurity(ev)) { // view没有被遮罩,一般都成立
final int action = ev.getAction();
final int actionMasked = action & MotionEvent.ACTION_MASK;
// Handle an initial down.
if (actionMasked == MotionEvent.ACTION_DOWN) { // 一堆touch事件(从按下到松手)中的第一个down事件
// Throw away all previous state when starting a new touch gesture.
// The framework may have dropped the up or cancel event for the previous gesture
// due to an app switch, ANR, or some other state change.
cancelAndClearTouchTargets(ev);
resetTouchState(); // 作为新一轮的开始,reset所有相关的状态
}
// Check for interception.
final boolean intercepted; // 检查是否要拦截
if (actionMasked == MotionEvent.ACTION_DOWN // down事件
|| mFirstTouchTarget != null) { // 或者之前的某次事件已经经由此ViewGroup派发给children后被处理掉了
final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
if (!disallowIntercept) { // 只有允许拦截才执行onInterceptTouchEvent方法
intercepted = onInterceptTouchEvent(ev); // 默认返回false,不拦截
ev.setAction(action); // restore action in case it was changed
} else {
intercepted = false; // 不允许拦截的话,直接设为false
}
} else {
// There are no touch targets and this action is not an initial down
// so this view group continues to intercept touches.
// 在这种情况下,actionMasked != ACTION_DOWN && mFirstTouchTarget == null
// 第一次的down事件没有被此ViewGroup的children处理掉(要么是它们自己不处理,要么是ViewGroup从一
// 开始的down事件就开始拦截),则接下来的所有事件
// 也没它们的份,即不处理down事件的话,那表示你对后面接下来的事件也不感兴趣
intercepted = true; // 这种情况下设置ViewGroup拦截接下来的事件
}
// Check for cancelation.
final boolean canceled = resetCancelNextUpFlag(this)
|| actionMasked == MotionEvent.ACTION_CANCEL; // 此touch事件是否取消了
// Update list of touch targets for pointer down, if needed.
// 是否拆分事件,3.0(包括)之后引入的,默认拆分
final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0;
TouchTarget newTouchTarget = null; // 接下来ViewGroup判断要将此touch事件交给谁处理
boolean alreadyDispatchedToNewTouchTarget = false;
if (!canceled && !intercepted) { // 没取消也不拦截,即是个有效的touch事件
if (actionMasked == MotionEvent.ACTION_DOWN // 第一个手指down
|| (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN) // 接下来的手指down
|| actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
final int actionIndex = ev.getActionIndex(); // always 0 for down
final int idBitsToAssign = split ? 1 << ev.getPointerId(actionIndex)
: TouchTarget.ALL_POINTER_IDS;
// Clean up earlier touch targets for this pointer id in case they
// have become out of sync.
removePointersFromTouchTargets(idBitsToAssign);
final int childrenCount = mChildrenCount;
if (newTouchTarget == null && childrenCount != 0) { // 基本都成立
final float x = ev.getX(actionIndex);
final float y = ev.getY(actionIndex);
// Find a child that can receive the event.
// Scan children from front to back.
final View[] children = mChildren;
final boolean customOrder = isChildrenDrawingOrderEnabled();
// 从最后一个向第一个找
for (int i = childrenCount - 1; i >= 0; i--) {
final int childIndex = customOrder ?
getChildDrawingOrder(childrenCount, i) : i;
final View child = children[childIndex];
if (!canViewReceivePointerEvents(child)
|| !isTransformedTouchPointInView(x, y, child, null)) {
continue; // 不满足这2个条件直接跳过,看下一个child
}
// child view能receive touch事件而且touch坐标也在view边界内
newTouchTarget = getTouchTarget(child);// 查找child对应的TouchTarget
if (newTouchTarget != null) { // 比如在同一个child上按下了多跟手指
// Child is already receiving touch within its bounds.
// Give it the new pointer in addition to the ones it is handling.
newTouchTarget.pointerIdBits |= idBitsToAssign;
break; // newTouchTarget已经有了,跳出for循环
}
resetCancelNextUpFlag(child);
// 将此事件交给child处理
// 有这种情况,一个手指按在了child1上,另一个手指按在了child2上,以此类推
// 这样TouchTarget的链就形成了
if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
// Child wants to receive touch within its bounds.
mLastTouchDownTime = ev.getDownTime();
mLastTouchDownIndex = childIndex;
mLastTouchDownX = ev.getX();
mLastTouchDownY = ev.getY();
// 如果处理掉了的话,将此child添加到touch链的头部
// 注意这个方法内部会更新 mFirstTouchTarget
newTouchTarget = addTouchTarget(child, idBitsToAssign);
alreadyDispatchedToNewTouchTarget = true; // down或pointer_down事件已经被处理了
break; // 可以退出for循环了。。。
}
}
}
// 本次没找到newTouchTarget但之前的mFirstTouchTarget已经有了
if (newTouchTarget == null && mFirstTouchTarget != null) {
// Did not find a child to receive the event.
// Assign the pointer to the least recently added target.
newTouchTarget = mFirstTouchTarget;
while (newTouchTarget.next != null) {
newTouchTarget = newTouchTarget.next;
}
// while结束后,newTouchTarget指向了最初的TouchTarget
newTouchTarget.pointerIdBits |= idBitsToAssign;
}
}
}
// 非down事件直接从这里开始处理,不会走上面的一大堆寻找TouchTarget的逻辑
// Dispatch to touch targets.
if (mFirstTouchTarget == null) {
// 没有children处理则派发给自己处理
// No touch targets so treat this as an ordinary view.
handled = dispatchTransformedTouchEvent(ev, canceled, null,
TouchTarget.ALL_POINTER_IDS);
} else {
// Dispatch to touch targets, excluding the new touch target if we already
// dispatched to it. Cancel touch targets if necessary.
TouchTarget predecessor = null;
TouchTarget target = mFirstTouchTarget;
while (target != null) { // 遍历TouchTarget形成的链表
final TouchTarget next = target.next;
if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
handled = true; // 已经处理过的不再让其处理事件
} else {
// 取消child标记
final boolean cancelChild = resetCancelNextUpFlag(target.child)
|| intercepted;
// 如果ViewGroup从半路拦截了touch事件则给touch链上的child发送cancel事件
// 如果cancelChild为true的话
if (dispatchTransformedTouchEvent(ev, cancelChild,
target.child, target.pointerIdBits)) {
handled = true; // TouchTarget链中任意一个处理了则设置handled为true
}
if (cancelChild) { // 如果是cancelChild的话,则回收此target节点
if (predecessor == null) {
mFirstTouchTarget = next;
} else {
predecessor.next = next; // 相当于从链表中删除一个节点
}
target.recycle(); // 回收它
target = next;
continue;
}
}
predecessor = target; // 访问下一个节点
target = next;
}
}
// Update list of touch targets for pointer up or cancel, if needed.
if (canceled
|| actionMasked == MotionEvent.ACTION_UP
|| actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
// 取消或up事件时resetTouchState
resetTouchState();
} else if (split && actionMasked == MotionEvent.ACTION_POINTER_UP) {
// 当某个手指抬起时,将其相关的信息移除
final int actionIndex = ev.getActionIndex();
final int idBitsToRemove = 1 << ev.getPointerId(actionIndex);
removePointersFromTouchTargets(idBitsToRemove);
}
}
if (!handled && mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onUnhandledEvent(ev, 1);
}
return handled; // 返回处理的结果
}
在看看ViewGroup的拦截方法
public boolean onInterceptTouchEvent(MotionEvent ev) {
return false; // 其默认直接返回false,表示不拦截
}
最后为了完整性,我这里把TouchTarget相关的方法都列一下以便大家参考:
/**
* Resets all touch state in preparation for a new cycle.
*/
private void resetTouchState() {
clearTouchTargets();
resetCancelNextUpFlag(this);
mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;
}
/**
* Resets the cancel next up flag.
* Returns true if the flag was previously set.
*/
private static boolean resetCancelNextUpFlag(View view) {
if ((view.mPrivateFlags & PFLAG_CANCEL_NEXT_UP_EVENT) != 0) {
view.mPrivateFlags &= ~PFLAG_CANCEL_NEXT_UP_EVENT;
return true;
}
return false;
}
/**
* Clears all touch targets.
*/
private void clearTouchTargets() {
TouchTarget target = mFirstTouchTarget;
if (target != null) {
do {
TouchTarget next = target.next;
target.recycle();
target = next;
} while (target != null);
mFirstTouchTarget = null;
}
}
/**
* Cancels and clears all touch targets.
*/
private void cancelAndClearTouchTargets(MotionEvent event) {
if (mFirstTouchTarget != null) {
boolean syntheticEvent = false;
if (event == null) {
final long now = SystemClock.uptimeMillis();
event = MotionEvent.obtain(now, now,
MotionEvent.ACTION_CANCEL, 0.0f, 0.0f, 0);
event.setSource(InputDevice.SOURCE_TOUCHSCREEN);
syntheticEvent = true;
}
for (TouchTarget target = mFirstTouchTarget; target != null; target = target.next) {
resetCancelNextUpFlag(target.child);
dispatchTransformedTouchEvent(event, true, target.child, target.pointerIdBits);
}
clearTouchTargets();
if (syntheticEvent) {
event.recycle();
}
}
}
/**
* Gets the touch target for specified child view.
* Returns null if not found.
*/
private TouchTarget getTouchTarget(View child) {
for (TouchTarget target = mFirstTouchTarget; target != null; target = target.next) {
if (target.child == child) {
return target;
}
}
return null;
}
/**
* Adds a touch target for specified child to the beginning of the list.
* Assumes the target child is not already present.
*/
private TouchTarget addTouchTarget(View child, int pointerIdBits) {
TouchTarget target = TouchTarget.obtain(child, pointerIdBits);
target.next = mFirstTouchTarget;
mFirstTouchTarget = target;
return target;
}
/**
* Removes the pointer ids from consideration.
*/
private void removePointersFromTouchTargets(int pointerIdBits) {
TouchTarget predecessor = null;
TouchTarget target = mFirstTouchTarget;
while (target != null) {
final TouchTarget next = target.next;
if ((target.pointerIdBits & pointerIdBits) != 0) {
target.pointerIdBits &= ~pointerIdBits;
if (target.pointerIdBits == 0) {
if (predecessor == null) {
mFirstTouchTarget = next;
} else {
predecessor.next = next;
}
target.recycle();
target = next;
continue;
}
}
predecessor = target;
target = next;
}
}
// 类似从链表中删除某个特定的节点
private void cancelTouchTarget(View view) {
TouchTarget predecessor = null;
TouchTarget target = mFirstTouchTarget;
while (target != null) {
final TouchTarget next = target.next;
if (target.child == view) {
if (predecessor == null) {
mFirstTouchTarget = next;
} else {
predecessor.next = next;
}
target.recycle();
final long now = SystemClock.uptimeMillis();
MotionEvent event = MotionEvent.obtain(now, now,
MotionEvent.ACTION_CANCEL, 0.0f, 0.0f, 0);
event.setSource(InputDevice.SOURCE_TOUCHSCREEN);
view.dispatchTouchEvent(event);
event.recycle();
return;
}
predecessor = target;
target = next;
}
}
对于以上的理解,来自android开发艺术探索以及http://www.cnblogs.com/xiaoweiz/p/3838682.html这个链接的理解。