Android View
前言
View是所有可视化空间的父类，系统提供了很多基础控件，比如Button，TextView等，但是仅仅使用他们是完全不能满足需求的，因此我们就需要自定义控件，而自定义控件，就需要对Android的View体系有充分的了解。有一个经典场景就是屏幕的滑动，当处于不同层级的View都响应用户滑动，就会导致滑动冲突。为了正常的响应滑动事件，我们就要对View的事件分发机制有充分的了解。
View基础知识
我们先从实践出发，了解View的一些功能。再深入去了解他在复杂场景的下的使用方法。
View的子类
View是Android中所有控件的父类，除了View以外，还有一个View的子类叫做ViewGroup，从名字上看，表示控件组，这意味着View不单单指一个，他也可以是一组控件。
所以Button是一个View，不是ViewGroup，而LinearLayout既是View又是ViewGroup。并且ViewGroup的内部，既可以有View，也可以有ViewGroup。
View的位置
View的位置由四个顶点决定，分别是bottom，top，left，right。这些坐标都是相对于View的父容器而言，因此它是相对坐标。
我们可以使用getLeft（），getRight（），getTop（），getBottom（）来获得View的位置。
Android3额外增加了几个参数：x、y、translationX、translationY。换算关系为 x = left + translationX。（需要实践）
View 在平移的过程中，top 和 left 表示的是原始左上角的位置信息，其值并不会发生改变，此时发生改变的是x、y、translationX和 translationY这四个参数。
View的触碰事件
1、MotionEvent
ACTION_DOWN--手指刚解除屏幕
ACTION_MOVE--手指在屏幕上移动
ACTIONUP -- 手指松开一瞬间
一般有手机点击和手机滑动松开的两种情况。对应的为down-up , down-move-up。
视图类中重写onTouchEvent方法
@Override
public boolean onTouchEvent(MotionEvent event) {
Log.d("Action",""+event.getAction());
float x = event.getX();//带event才是触摸点坐标，不带为view坐标，并且X是相对view的坐标，view的左上角为0，0。只有rawX才是整个屏幕的
float y = event.getY();
Log.d("public button",x+" "+y);
return true;
}2、 TouchSlop
TouchSlop是系统所能识别为滑动的最小距离，不同设备不同。是一个常量
ViewConfiguration.get（getContextO）.getScaledTouchSlop（）
3、VelocityTracker
速度追踪，能够识别在一段时间内，手指滑动的速度
视图类中重写onTouchEvent方法
@Override
public boolean onTouchEvent(MotionEvent event) {
VelocityTracker velocityTracker= VelocityTracker.obtain();
velocityTracker.addMovement (event);
velocityTracker.computeCurrentVelocity (1000);
int xVelocity =(int) velocityTracker.getXVelocity();
int yVelocity =(int) velocityTracker.getYVelocity();
Log.d("speed",xVelocity+" "+yVelocity);
return true;
}4、GestureDetector
手势检测。可以检测长按，轻触，单击，双击等行为。需要先创建一个监听器对象GestureDetector.OnGestureListener，然后创建GestureDetector时传入监听器，再为视图设置TouchEvent监听器，在onTouch事件中使用GestureDetector接管即可
GestureDetector.OnGestureListener listener = new GestureDetector.OnGestureListener() {
@Override
public boolean onDown(MotionEvent e) {
Log.d("down","down");
return false;
}
@Override
public void onShowPress(MotionEvent e) {
}
@Override
public boolean onSingleTapUp(MotionEvent e) {
return false;
}
@Override
public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
return false;
}
@Override
public void onLongPress(MotionEvent e) {
}
@Override
public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
return false;
}
};
LinearLayout ll = findViewById(R.id.MA_ll);
GestureDetector gestureDetector= new GestureDetector(this,listener);
ll.setOnTouchListener(new View.OnTouchListener() {
@Override
public boolean onTouch(View v, MotionEvent event) {
return gestureDetector.onTouchEvent(event);
}
});5、Scroller
弹性滑动，实现组件的缓慢移动
View的滑动
视图手指滑动
@Override
public boolean onTouchEvent(MotionEvent event) {
//每次回调onTouchEvent的时候，我们获取触摸点的代码
int x = (int) event.getX();
int y = (int) event.getY();
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
// 记录触摸点坐标
lastX = x;
lastY = y;
break;
case MotionEvent.ACTION_MOVE:
// 计算偏移量
int offsetX = x - lastX;
int offsetY = y - lastY;
// 在当前left、top、right、bottom的基础上加上偏移量
layout(getLeft() + offsetX,
getTop() + offsetY,
getRight() + offsetX,
getBottom() + offsetY);
break;
}
return true;
}Scroll滑动
被谁捕获就移动谁
public PublicButton1(Context context, AttributeSet attrs) {
super(context, attrs);
LayoutInflater.from(context).inflate(R.layout.button1,this);//加载某个布局，并为他添加父布局
Button qwq = findViewById(R.id.publicButton);
LinearLayout linearLayout = findViewById(R.id.linearlayout);
linearLayout.setBackgroundColor(getResources().getColor(R.color.design_default_color_secondary));
qwq.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
scrollBy(-10,-10);
}
});
scrollBy(-100,-100);
}动画滑动
待定
弹性滑动
Scroller实现，需要重写computeScroll方法
private void smoothScrollTo(int destX,int destY) {
int scrollX = getScrollX();
int deltaX = destX - scrollX;
scroller.startScroll(scrollX, 0, deltaX, 0, 1000);
invalidate();
}
@Override
public void computeScroll() {
if(scroller.computeScrollOffset())
{
scrollTo(scroller.getCurrX(),scroller.getCurrY());
postInvalidate();
}
}View的事件分发机制
点击事件的传递规则
分析的对象是MotionEvent，所谓对点击事件的分发，就是对MotionEvent的分发，系统需要把这个事件发给具体的一个View。
分发过程由三个方法共同完成：dispatchTouchEvent、onlnterceptTouchEvent和 onTouchEvent
public boolean dispatchTouchEvent(MotionEvent ev)
用来进行事件的分发。如果事件能够传递给当前View，那么此方法一定会被调用，返回结果受当前View 的 onTouchEvent 和下级 View 的 dispatchTouchEvent 方法的影响，表示是否消耗当前事件。
public boolean onInterceptTouchEvent(MotionEvent event)
在上述方法内部调用，用来判断是否拦截某个事件，如果当前View拦截了某个事件，那么在同一个事件序列当中，此方法不会被再次调用，返回结果表示是否拦截当前事件。
public boolean onTouchEvent(MotionEvent event)
在 dispatchTouchEvent 方法中调用，用来处理点击事件，返回结果表示是否消耗当前事件，如果不消耗，则在同一个事件序列中，当前View 无法再次接收到事件。
他们的关系可以用以下伪代码表示
public boolean dispatchTouchEvent(MotionEvent ev) {
boolean consume = false;
if (onInterceptTouchEvent(ev)) {
consume = onTouchEvent(ev);//或者listener先被调用
} else {
consume = child.dispatchTouchEvent(ev);
}
return consume;
}对于一个根ViewGroup来说，点击事件产生后，首先会传递给它，这时它的 dispatchTouchEvent就会被调用，
如果这个ViewGroup 的 onInterceptTouchEvent方法返回 true 就表示它要拦截当前事件，接着事件就会交给这个ViewGroup处理，即它的onTouchEvent方法就会被调用;
如果这个ViewGroup 的onInterceptTouchEvent方法返回 false就表示它不拦截当前事件，这时当前事件就会继续传递给它的子元素，
接着子元素的dispatchTouchEvent 方法就会被调用，如此反复直到事件被最终处理。
当一个View 需要处理事件时，
如果它设置了 OnTouchListener，那么OnTouchListener中的 onTouch方法会被回调。
这时事件如何处理还要看 onTouch 的返回值，
如果返回 false，则当前View的 onTouchEvent 方法会被调用;
如果返回 true，那么 onTouchEvent 方法将不会被调用。
可以把OnTouchListener理解为外部监听器，而onTouchEvent理解为内部监听器。onTouchListener在外部用set绑定，而onTouchEvent是重写组件方法实现的。
在 onTouchEvent 方法中，如果当前设置的有OnClickListener，那么它的 onClick 方法会被调用。可以看出，平时我们常用的 OnClickListener，其优先级最低，即处于事件传递的尾端。
当一个点击事件产生后，它的传递过程遵循如下顺序∶Activity->Window->View，顶级 View 接收到事件后，就会按照事件分发机制去分发事件。
总而言之就是，事件序列拦截从上到下（onlnterceptTouchEvent），事件处理从下到上（onTouchEvent）
一些结论
事件序列是指手指接触屏幕那一刻开始，手指离开屏幕结束。一般是down事件开始，中间很多move，最终up事件结束。
一般情况下，一个事件序列只能被一个View拦截且消耗。一旦一个元素拦截了某此事件，那么同一个事件序列内的所有事件都会直接交给它处理，但是也有其他特殊手段可以做到让其他View处理。
一个View一旦决定拦截，那么他的onlnterceptTouchEvent只会调用一次，系统会把同一个事件序列的其他方法交给onTouchEvent方法处理。
一个View一旦拦截了Down事件，那么之后的所有move，up事件都会交给他处理。
一个View一旦开始处理事件，如果他不处理事件序列的第一个事件，那么其他所有事件都会交给他的父元素的onTouchEvent处理。
一个View一旦开始处理事件，如果他只处理事件序列的第一个事件，那么这个点击事件会小时，并且父元素的onTouchEvent不会调用。消失的点击事件会传递给activity处理
ViewGroup默认不拦截任何事件。viewGroup 的 onlnterceptTouchEvent 方法默认返回 false。
View 没有 onlnterceptTouchEvent 方法，一旦有点击事件传递给它，那么它的onTouchEvent 方法就会被调用。
View的onTouchEvent默认都会消耗事件，除非它是不可点击的（clickable和longClickable 同时为 false）
事件传递过程是由外向内的，即事件总是先传递给父元素，然后再由父元素分发给子 View。
事件分发源码分析
前面对大概了解了一个事件是怎么样分发的，接下来更深入得从源码角度分析。
Activity对点击事件的分发过程
MotionEvent最先传递给Activity，Activity的dispatchTouchEvent负责事件派发，具体工作是有Activity内部的Window完成的。
Window会将事件传递给decor View。decor View 一般就是当前界面的底层容器（setContentView所设置的View的父容器）
通过getWindow.getDecorView（）可以获得。
先分析Activity的dispatchTouchEvent
public boolean dispatchTouchEvent(MotionEvent ev)
{
if(ev.getAction()==MotionEvent.ACTION_DOWN)
{
onUserInteraction();
}
if(getWindow().superDispatchGenericMotionEvent(ev))
{
return true;
}
return onTouchEvent(ev);
}可以看到Window类通过调用superDispatchTouchEvent方法分发事件，但是window类是个抽象类，它的具体实现是phonewindow。我们找到了它的具体实现↓
@Override
public boolean superDispatchTouchEvent(MotionEvent event) {
return mDecor.superDispatchTouchEvent(event);
}可以看到phonewindow类把事件发给了DecorView。而DecorView继承自FrameLayout，根据前面的一些结论可以知道ViewGroup默认不拦截事件，所以一定会传递到View。这里有一个概念顶级View和根View，他们指的的DecorView的子View，即我们setContentView所设置的view。
ViewGroup事件分发
下面我们来看顶级View的分发过程，先分析DispatchTouchEvent的源码，下面这段主要描述的是是否拦截这个事件的逻辑
// Check for interception.
final boolean intercepted;
if (actionMasked == MotionEvent.ACTION_DOWN
|| mFirstTouchTarget != null) {
final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
if (!disallowIntercept) {
intercepted = onInterceptTouchEvent(ev);
ev.setAction(action); // restore action in case it was changed
} else {
intercepted = false;
}
} else {
// There are no touch targets and this action is not an initial down
// so this view group continues to intercept touches.
intercepted = true;
}ViewGroup在两种情况下回判断是否拦截：
mFirstTouchTarget已经被赋值或者当前事件为Action_Down。
mFirstTouchTarget的含义是当事件由子View成功处理时，该成员就会被赋值指向子元素。即当ViewGroup拦截时，mFirstTouchTarget为空，那么条件就不成立，就不会再次进行拦截。拦截方法就不会调用第二次。
设置了FLAG DISALLOW INTERCEPT标志位后，ViewGroup无法拦截除了down以外的其他事件。Flag位可以在子View中调用一个方法修改，但是当down事件来临前，这个flag会被充值为false。所以子View不能影响ViewGroup处理down事件。
第一点，onlnterceptTouchEvent 不是每次事件都会被调用的，如果我们想提前处理所有的点击事件，要选择 dispatchTouchEvent 方法，只有这个方法能确保每次都会调用，当然前提是事件能够传递到当前的 ViewGroup;另外一点，FLAG DISALLOW INTERCEPT标记位的作用给我们提供了一个思路，当面对滑动冲突时，我们可以是不是考虑用这种方法去解决问题?
再看当 ViewGroup 不拦截事件的时候，事件会向下分发交由它的子 View 进行处理，这段源码如下所示。
// Find a child that can receive the event.
// Scan children from front to back.
final ArrayList<View> preorderedList = buildTouchDispatchChildList();
final boolean customOrder = preorderedList == null
&& isChildrenDrawingOrderEnabled();
final View[] children = mChildren;
for (int i = childrenCount - 1; i >= 0; i--) {
final int childIndex = getAndVerifyPreorderedIndex(
childrenCount, i, customOrder);
final View child = getAndVerifyPreorderedView(
preorderedList, children, childIndex);
// If there is a view that has accessibility focus we want it
// to get the event first and if not handled we will perform a
// normal dispatch. We may do a double iteration but this is
// safer given the timeframe.
if (childWithAccessibilityFocus != null) {
if (childWithAccessibilityFocus != child) {
continue;
}
childWithAccessibilityFocus = null;
i = childrenCount - 1;
}
if (!child.canReceivePointerEvents()
|| !isTransformedTouchPointInView(x, y, child, null)) {
ev.setTargetAccessibilityFocus(false);
continue;
}
newTouchTarget = getTouchTarget(child);
if (newTouchTarget != null) {
// 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;
}
resetCancelNextUpFlag(child);
if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
// Child wants to receive touch within its bounds.
mLastTouchDownTime = ev.getDownTime();
if (preorderedList != null) {
// childIndex points into presorted list, find original index
for (int j = 0; j < childrenCount; j++) {
if (children[childIndex] == mChildren[j]) {
mLastTouchDownIndex = j;
break;
}
}
} else {
mLastTouchDownIndex = childIndex;
}
mLastTouchDownX = ev.getX();
mLastTouchDownY = ev.getY();
newTouchTarget = addTouchTarget(child, idBitsToAssign);
alreadyDispatchedToNewTouchTarget = true;
break;
}根据是否播放动画（canReceivePointerEvents），触摸点是否在View的范围（isTransformedTouchPointInView）内分发事件（dispatchTransformedTouchEvent）的结果，决定是让该子元素处理，还是改为下一个子元素处理。
实际上ViewGroup分发事件就是调用子元素的dispatchTouchEvent来完成事件分发的
private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
View child, int desiredPointerIdBits) {
final boolean handled;
// Canceling motions is a special case. We don't need to perform any transformations
// or filtering. The important part is the action, not the contents.
final int oldAction = event.getAction();
if (cancel || oldAction == MotionEvent.ACTION_CANCEL) {
event.setAction(MotionEvent.ACTION_CANCEL);
if (child == null) {
handled = super.dispatchTouchEvent(event);
} else {
handled = child.dispatchTouchEvent(event);
}
event.setAction(oldAction);
return handled;
}如果子元素的dispatchTouchEvent返回 false，ViewGroup 就会把事件分发给下一个子元素
mFirstTouchTarget 其实是一种单链表结构。mFirstTouchTarget 是否被赋值，将直接影响到 ViewGroup 对事件的拦截策略，如果mFirstTouchTarget为 null，那么ViewGroup 就默认拦截接下来同一序列中所有的点击事件。
如果遍历所有的子元素后事件都没有被合适地处理，这包含两种情况;第一种是ViewGroup 没有子元素;第二种是子元素处理了点击事件，但是在dispatchTouchEvent 中返回了 false，这一般是因为子元素在 onTouchEvent 中返回了 false。在这两种情况下，ViewGroup 会自已处理点击事件
View对点击事件的处理过程
View 对点击事件的处理过程，首先会判断有没有设置 OnTouchListener。如果 OnTouchListener中的 onTouch方法返回 true，那么 onTouchEvent 就不会被调用。
public boolean dispatchTouchEvent(MotionEvent event) {
// If the event should be handled by accessibility focus first.
if (event.isTargetAccessibilityFocus()) {
// We don't have focus or no virtual descendant has it, do not handle the event.
if (!isAccessibilityFocusedViewOrHost()) {
return false;
}
// We have focus and got the event, then use normal event dispatch.
event.setTargetAccessibilityFocus(false);
}
boolean result = false;
if (mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onTouchEvent(event, 0);
}
final int actionMasked = event.getActionMasked();
if (actionMasked == MotionEvent.ACTION_DOWN) {
// Defensive cleanup for new gesture
stopNestedScroll();
}
if (onFilterTouchEventForSecurity(event)) {
if ((mViewFlags & ENABLED_MASK) == ENABLED && handleScrollBarDragging(event)) {
result = true;
}
//noinspection SimplifiableIfStatement
ListenerInfo li = mListenerInfo;
if (li != null && li.mOnTouchListener != null
&& (mViewFlags & ENABLED_MASK) == ENABLED
&& li.mOnTouchListener.onTouch(this, event)) {
result = true;
}
if (!result && onTouchEvent(event)) {
result = true;
}
}
if (!result && mInputEventConsistencyVerifier != null) {
mInputEventConsistencyVerifier.onUnhandledEvent(event, 0);
}
// Clean up after nested scrolls if this is the end of a gesture;
// also cancel it if we tried an ACTION_DOWN but we didn't want the rest
// of the gesture.
if (actionMasked == MotionEvent.ACTION_UP ||
actionMasked == MotionEvent.ACTION_CANCEL ||
(actionMasked == MotionEvent.ACTION_DOWN && !result)) {
stopNestedScroll();
}
return result;
}onTouchEvent方法中不可用状态下的View照样会消耗点击事件
CLICKABLE和LONG CLICKABLE有一个为 true，那么它就会消耗这个事件
public boolean onTouchEvent(MotionEvent event) {
final float x = event.getX();
final float y = event.getY();
final int viewFlags = mViewFlags;
final int action = event.getAction();
final boolean clickable = ((viewFlags & CLICKABLE) == CLICKABLE
|| (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
|| (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE;
if ((viewFlags & ENABLED_MASK) == DISABLED
&& (mPrivateFlags4 & PFLAG4_ALLOW_CLICK_WHEN_DISABLED) == 0) {
if (action == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
setPressed(false);
}
mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
// A disabled view that is clickable still consumes the touch
// events, it just doesn't respond to them.
return clickable;
}
if (mTouchDelegate != null) {
if (mTouchDelegate.onTouchEvent(event)) {
return true;
}
}
if (clickable || (viewFlags & TOOLTIP) == TOOLTIP) {
switch (action) {
case MotionEvent.ACTION_UP:
mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
if ((viewFlags & TOOLTIP) == TOOLTIP) {
handleTooltipUp();
}
if (!clickable) {
removeTapCallback();
removeLongPressCallback();
mInContextButtonPress = false;
mHasPerformedLongPress = false;
mIgnoreNextUpEvent = false;
break;
}
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;
if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {
focusTaken = requestFocus();
}
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.
setPressed(true, x, y);
}
if (!mHasPerformedLongPress && !mIgnoreNextUpEvent) {
// This is a tap, so remove the longpress check
removeLongPressCallback();
// Only perform take click actions if we were in the pressed state
if (!focusTaken) {
// Use a Runnable and post this rather than calling
// performClick directly. This lets other visual state
// of the view update before click actions start.
if (mPerformClick == null) {
mPerformClick = new PerformClick();
}
if (!post(mPerformClick)) {
performClickInternal();
}
}
}
if (mUnsetPressedState == null) {
mUnsetPressedState = new UnsetPressedState();
}
if (prepressed) {
postDelayed(mUnsetPressedState,
ViewConfiguration.getPressedStateDuration());
} else if (!post(mUnsetPressedState)) {
// If the post failed, unpress right now
mUnsetPressedState.run();
}
removeTapCallback();
}
mIgnoreNextUpEvent = false;
break;
case MotionEvent.ACTION_DOWN:
if (event.getSource() == InputDevice.SOURCE_TOUCHSCREEN) {
mPrivateFlags3 |= PFLAG3_FINGER_DOWN;
}
mHasPerformedLongPress = false;
if (!clickable) {
checkForLongClick(
ViewConfiguration.getLongPressTimeout(),
x,
y,
TOUCH_GESTURE_CLASSIFIED__CLASSIFICATION__LONG_PRESS);
break;
}
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) {
mPrivateFlags |= PFLAG_PREPRESSED;
if (mPendingCheckForTap == null) {
mPendingCheckForTap = new CheckForTap();
}
mPendingCheckForTap.x = event.getX();
mPendingCheckForTap.y = event.getY();
postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
} else {
// Not inside a scrolling container, so show the feedback right away
setPressed(true, x, y);
checkForLongClick(
ViewConfiguration.getLongPressTimeout(),
x,
y,
TOUCH_GESTURE_CLASSIFIED__CLASSIFICATION__LONG_PRESS);
}
break;
case MotionEvent.ACTION_CANCEL:
if (clickable) {
setPressed(false);
}
removeTapCallback();
removeLongPressCallback();
mInContextButtonPress = false;
mHasPerformedLongPress = false;
mIgnoreNextUpEvent = false;
mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
break;
case MotionEvent.ACTION_MOVE:
if (clickable) {
drawableHotspotChanged(x, y);
}
final int motionClassification = event.getClassification();
final boolean ambiguousGesture =
motionClassification == MotionEvent.CLASSIFICATION_AMBIGUOUS_GESTURE;
int touchSlop = mTouchSlop;
if (ambiguousGesture && hasPendingLongPressCallback()) {
if (!pointInView(x, y, touchSlop)) {
// The default action here is to cancel long press. But instead, we
// just extend the timeout here, in case the classification
// stays ambiguous.
removeLongPressCallback();
long delay = (long) (ViewConfiguration.getLongPressTimeout()
* mAmbiguousGestureMultiplier);
// Subtract the time already spent
delay -= event.getEventTime() - event.getDownTime();
checkForLongClick(
delay,
x,
y,
TOUCH_GESTURE_CLASSIFIED__CLASSIFICATION__LONG_PRESS);
}
touchSlop *= mAmbiguousGestureMultiplier;
}
// Be lenient about moving outside of buttons
if (!pointInView(x, y, touchSlop)) {
// Outside button
// Remove any future long press/tap checks
removeTapCallback();
removeLongPressCallback();
if ((mPrivateFlags & PFLAG_PRESSED) != 0) {
setPressed(false);
}
mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
}
final boolean deepPress =
motionClassification == MotionEvent.CLASSIFICATION_DEEP_PRESS;
if (deepPress && hasPendingLongPressCallback()) {
// process the long click action immediately
removeLongPressCallback();
checkForLongClick(
0 /* send immediately */,
x,
y,
TOUCH_GESTURE_CLASSIFIED__CLASSIFICATION__DEEP_PRESS);
}
break;
}
return true;
}
return false;
}设置了 OnClickListener，那么 performClick 方法内部会调用它的 onClick
View的LONG_CLICKABLE 属性默认为 false，而CLICKABLE属性是否为 false 和具体的View 有关
View的滑动冲突
常见的滑动冲突场景可以简单分为如下三种
场景1———外部滑动方向和内部滑动方向不一致。左右滑动切换页面，上下滑动ListView。
场景2———外部滑动方向和内部滑动方向一致;
场景3-上面两种情况的嵌套。
如果没有处理滑动冲突，就会造成内外两层只有一层能够滑动
滑动冲突处理
外部拦截法
事件都先经过父容器的拦截处理，如果父容器需要此事件就拦截，如果不需要此事件就不拦截
内部拦截法
内部拦截法是指父容器不拦截任何事件，所有的事件都传递给子元素，如果子元素需要此事件就直接消耗掉，否则就交由父容器进行处理，这种方法和 Android中的事件分发机制不一致，需要配合 requestDisallowInterceptTouchEvent 方法才能正常工作。
实例
场景一：父容器可以水平滑动，多个子容器ListView可以垂直滑动。
外部拦截法实例
父容器重写onInterceptTouchEvent方法，不拦截down，根据水平垂直差拦截move，不拦截up。赋值lastX，lastY。return Intercept。
父容器重写onTouchEvent方法，在里面处理视图的移动，使用scrollby。
内部拦截法实例
父容器默认拦截MOVE和UP事件
使用parent.requestdisallowInterceptTouchEvent（）方法修改子容器dispatchTouchEvent 方法中的父容器的拦截逻辑。比如dX>dY时，调用parent.requestdisallowInterceptTouchEvent（false），使父容器拦截事件。
View的工作原理
View的三大流程：measure、layout、draw
初始ViewRoot，DecorView
ViewRoot对应于ViewRootImpl类，是连接DecorView和WindowManager的纽带。View的三大流程均是通过ViewRoot来完成的。
ActivityThread 中，当Activity 对象被创建完毕后，会将 DecorView 添加到 Window 中，同时会创建 ViewRootlmpl 对象，并将ViewRootlmpl 对象和 DecorView 建立关联
View 的绘制流程是从ViewRoot 的 performTraversals 方法开始的，它经过 measure、layout 和 draw三个过程才能最终将一个View绘制出来，其中 measure 用来测量 View 的宽和高，layout 用来确定 View在父容器中的放置位置，而 draw 则负责将 View 绘制在屏幕上。
如图所示performTraversals 会依次调用 performMeasure、performLayout 和performDraw三个方法，这三个方法分别完成顶级View 的measure、layout 和 draw这三大流程。
如图所示DecorView 作为顶级View，一般情况下它内部会包含一个竖直方向的LinearLayout，在这个LinearLayout 里面有上下两个部分（具体情况和 Android版本及主题有关），上面是标题栏，下面是内容栏。
setContentView所设置的布局文件其实就是被加到内容栏之中的，而内容栏的 id是 content。
如何得到 content 呢?可以这样∶ViewGroup content= findViewByld（R.android.id.content）。
如何得到我们设置的View 呢?可以这样∶content.getChildAt（0）
View 层的事件都先经过DecorView，然后才传递给我们的View。
理解MeasureSpec
MeasureSpec参与了View的measure过程。MeasureSpec在很大程度上决定了View的尺寸规格，部分受到父容器的影响。
MeasureSpec代表一个32位int值，高2位表示SpecMode，低30位表示specSize。SpecSize是指在某种测量模式下的规格大小。
SpecMode有三类：UNSPECIFIED（不限大小），EXACTLY（精确大小，对应于LayoutParams中match_parent和具体数值两种模式），AT_MOST（指定了可用大小，View不能超过这个值）。
MeasureSpec 不是唯一由LayoutParams 决定的，LayoutParams 需要和父容器的MeasureSpec一起才能决定 View的MeasureSpec，从而进一步决定View的宽/高。
MeasureSpec一旦确定后，onMeasure 中就可以确定View的测量宽/高。
View的工作流程
View的三大流程：measure、layout、draw
Measure
Measure过程分为两种情况，一种是View的测量，一种是ViewGroup的测量。View只需要测量自己，而ViewGroup还需要测量子View。
View的measure
measure方法会调用到onMeasure方法
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
}setMeasuredDimension方法会设置View宽高的测量值。再看一下getDefaultSize
public static int getDefaultSize(int size, int measureSpec) {
int result = size;
int specMode = MeasureSpec.getMode(measureSpec);
int specSize = MeasureSpec.getSize(measureSpec);
switch (specMode) {
case MeasureSpec.UNSPECIFIED:
result = size;
break;
case MeasureSpec.AT_MOST:
case MeasureSpec.EXACTLY:
result = specSize;
break;
}
return result;
}其实getDefaultSize返回的大小就是measureSpec 中的 specSize，而这个
specSize就是View 测量后的大小，这里多次提到测量后的大小，是因为View最终的大小是在layout阶段确定的，所以这里必须要加以区分。
浙公网安备 33010602011771号