Android从源码的角度彻底理解事件分发机制的解析(下)

public class MyLayout extends LinearLayout { 
 public MyLayout(Context context, AttributeSet attrs) { 
 super(context, attrs); 
 } 
} 

<com.example.viewgrouptouchevent.MyLayout xmlns:android="http://schemas.android.com/apk/res/android" 
 xmlns:tools="http://schemas.android.com/tools" 
 android:id="@+id/my_layout" 
 android:layout_width="match_parent" 
 android:layout_height="match_parent" 
 android:orientation="vertical" > 
 <Button 
 android:id="@+id/button1" 
 android:layout_width="match_parent" 
 android:layout_height="wrap_content" 
 android:text="Button1" /> 
 <Button 
 android:id="@+id/button2" 
 android:layout_width="match_parent" 
 android:layout_height="wrap_content" 
 android:text="Button2" /> 
 
</com.example.viewgrouptouchevent.MyLayout> 

myLayout.setOnTouchListener(new OnTouchListener() { 
 @Override 
 public boolean onTouch(View v, MotionEvent event) { 
 Log.d("TAG", "myLayout on touch"); 
 return false; 
 } 
}); 
button1.setOnClickListener(new OnClickListener() { 
 @Override 
 public void onClick(View v) { 
 Log.d("TAG", "You clicked button1"); 
 } 
}); 
button2.setOnClickListener(new OnClickListener() { 
 @Override 
 public void onClick(View v) { 
 Log.d("TAG", "You clicked button2"); 
 } 
}); 

/** 
 * Implement this method to intercept all touch screen motion events. This 
 * allows you to watch events as they are dispatched to your children, and 
 * take ownership of the current gesture at any point. 
 * 
 * <p>Using this function takes some care, as it has a fairly complicated 
 * interaction with {@link View#onTouchEvent(MotionEvent) 
 * View.onTouchEvent(MotionEvent)}, and using it requires implementing 
 * that method as well as this one in the correct way. Events will be 
 * received in the following order: 
 * 
 * <ol> 
 * <li> You will receive the down event here. 
 * <li> The down event will be handled either by a child of this view 
 * group, or given to your own onTouchEvent() method to handle; this means 
 * you should implement onTouchEvent() to return true, so you will 
 * continue to see the rest of the gesture (instead of looking for 
 * a parent view to handle it). Also, by returning true from 
 * onTouchEvent(), you will not receive any following 
 * events in onInterceptTouchEvent() and all touch processing must 
 * happen in onTouchEvent() like normal. 
 * <li> For as long as you return false from this function, each following 
 * event (up to and including the final up) will be delivered first here 
 * and then to the target's onTouchEvent(). 
 * <li> If you return true from here, you will not receive any 
 * following events: the target view will receive the same event but 
 * with the action {@link MotionEvent#ACTION_CANCEL}, and all further 
 * events will be delivered to your onTouchEvent() method and no longer 
 * appear here. 
 * </ol> 
 * 
 * @param ev The motion event being dispatched down the hierarchy. 
 * @return Return true to steal motion events from the children and have 
 * them dispatched to this ViewGroup through onTouchEvent(). 
 * The current target will receive an ACTION_CANCEL event, and no further 
 * messages will be delivered here. 
 */ 
public boolean onInterceptTouchEvent(MotionEvent ev) { 
 return false; 
} 

public class MyLayout extends LinearLayout { 
 public MyLayout(Context context, AttributeSet attrs) { 
 super(context, attrs); 
 } 
 @Override 
 public boolean onInterceptTouchEvent(MotionEvent ev) { 
 return true; 
 } 
 
} 

public boolean dispatchTouchEvent(MotionEvent ev) { 
 final int action = ev.getAction(); 
 final float xf = ev.getX(); 
 final float yf = ev.getY(); 
 final float scrolledXFloat = xf + mScrollX; 
 final float scrolledYFloat = yf + mScrollY; 
 final Rect frame = mTempRect; 
 boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0; 
 if (action == MotionEvent.ACTION_DOWN) { 
 if (mMotionTarget != null) { 
  mMotionTarget = null; 
 } 
 if (disallowIntercept || !onInterceptTouchEvent(ev)) { 
  ev.setAction(MotionEvent.ACTION_DOWN); 
  final int scrolledXInt = (int) scrolledXFloat; 
  final int scrolledYInt = (int) scrolledYFloat; 
  final View[] children = mChildren; 
  final int count = mChildrenCount; 
  for (int i = count - 1; i >= 0; i--) { 
  final View child = children[i]; 
  if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE 
   || child.getAnimation() != null) { 
   child.getHitRect(frame); 
   if (frame.contains(scrolledXInt, scrolledYInt)) { 
   final float xc = scrolledXFloat - child.mLeft; 
   final float yc = scrolledYFloat - child.mTop; 
   ev.setLocation(xc, yc); 
   child.mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT; 
   if (child.dispatchTouchEvent(ev)) { 
    mMotionTarget = child; 
    return true; 
   } 
   } 
  } 
  } 
 } 
 } 
 boolean isUpOrCancel = (action == MotionEvent.ACTION_UP) || 
  (action == MotionEvent.ACTION_CANCEL); 
 if (isUpOrCancel) { 
 mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT; 
 } 
 final View target = mMotionTarget; 
 if (target == null) { 
 ev.setLocation(xf, yf); 
 if ((mPrivateFlags & CANCEL_NEXT_UP_EVENT) != 0) { 
  ev.setAction(MotionEvent.ACTION_CANCEL); 
  mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT; 
 } 
 return super.dispatchTouchEvent(ev); 
 } 
 if (!disallowIntercept && onInterceptTouchEvent(ev)) { 
 final float xc = scrolledXFloat - (float) target.mLeft; 
 final float yc = scrolledYFloat - (float) target.mTop; 
 mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT; 
 ev.setAction(MotionEvent.ACTION_CANCEL); 
 ev.setLocation(xc, yc); 
 if (!target.dispatchTouchEvent(ev)) { 
 } 
 mMotionTarget = null; 
 return true; 
 } 
 if (isUpOrCancel) { 
 mMotionTarget = null; 
 } 
 final float xc = scrolledXFloat - (float) target.mLeft; 
 final float yc = scrolledYFloat - (float) target.mTop; 
 ev.setLocation(xc, yc); 
 if ((target.mPrivateFlags & CANCEL_NEXT_UP_EVENT) != 0) { 
 ev.setAction(MotionEvent.ACTION_CANCEL); 
 target.mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT; 
 mMotionTarget = null; 
 } 
 return target.dispatchTouchEvent(ev); 
}