View详解

字数 4980阅读 113

3.4 View详解

3.10.1 概述

View系统定义了从用户输入消息到消息处理的全过程:用户通过触摸屏或者键盘输入消息后,该消息经过处理后,首先被送到WMS,WMS根据所有窗口的状态(每一个窗口都是WMS创建的,所以WMS知道所有窗口的信息)判断用户正在与哪个窗口进行交互,然后把该消息发送给该窗口:如果是按键消息,则直接发送给当前窗口,如果是触摸消息,则WMS会根据消息的位置坐标发送给相应的窗口,最后目标窗口怎么处理消息则是应用的业务逻辑了。

3.10.2 View基本知识

View的位置参数:top、left、right、bottom,分别对应View的左上角和右下角相对于父容器的横纵坐标值(平移过程中是不会变化的)。此外Android3.0增加了x、y、translationX、translationY四个参数,其中x和y是View左上角的坐标,而translationX和translationY是View左上角相对于父容器的偏移量,默认值是0。其关系如下:x=left+translationX,y=top+translationY。如下图所示:

MotionEvent是指手指接触屏幕后所产生的一系列事件,主要有ACTION_UP、ACTION_DOWN、ACTION_MOVE等。正常情况下,一次手指触屏会触发一系列点击事件,主要有下面两种典型情况:

  • 点击屏幕后离开,事件序列是ACTION_DOWN->ACTION_UP;
  • 点击屏幕后滑动一会再离开,事件序列是ACTION_DOWN->ACTION_MOVE->ACTION_MOVE->...->ACTION_UP。

通过MotionEvent可以得到点击事件的x和y坐标,其中getX和getY是相对于当前View左上角的x和y坐标,getRawX和getRawY是相对于手机屏幕左上角的x和y坐标。

VelocityTracker用于追踪手指在滑动过程中的速度,包括水平和垂直方向上的速度。具体计算公式如下所示:

speed = (endPosition - startPosition) / time

从上面公式可知:速度是单位时间内移动的像素数(速度可能为负值,例如当手指从屏幕右边往左边滑动的时候),可以使用方法computeCurrentVelocity(xxx)指定单位时间是多少。例如通过computeCurrentVelocity(1000)来获取速度,手指在1s中滑动了100个像素,那么速度是100,即100(像素/1000ms)。VelocityTracker的使用方式:

//初始化
VelocityTracker mVelocityTracker = VelocityTracker.obtain();
//在onTouchEvent方法中
mVelocityTracker.addMovement(event);
//获取速度
mVelocityTracker.computeCurrentVelocity(1000);
float xVelocity = mVelocityTracker.getXVelocity();
//重置和回收
mVelocityTracker.clear(); //一般在MotionEvent.ACTION_UP的时候调用
mVelocityTracker.recycle(); //一般在onDetachedFromWindow中调用

GestureDetector用于辅助检测用户的单击、滑动、长按、双击等行为。GestureDetector的使用比较简单,主要也是辅助检测常见的触屏事件。如果只是监听滑动相关的事件在onTouchEvent中实现,如果要监听双击这种行为的话,那么就使用GestureDetector。

3.10.3 View的事件体系

View的事件分发机制

事件分发过程有三个重要方法:

  • dispatchTouchEvent方法用来进行事件的分发。如果事件能够传递给当前View,那么此方法一定会被调用,返回结果受当前View的onTouchEvent和下级View的dispatchTouchEvent方法的影响,表示是否消耗当前事件。
  • onInterceptTouchEvent方法在dispatchTouchEvent方法内部调用,用来判断是否拦截某个事件。如果拦截(返回true)则自己消费该事件,即调用自己的onTouchEvent方法,否则传递给子view的dispatchTouchEvent方法,由子view处理该事件。需要注意的是,如果当前View拦截了某个事件,那么在同一个事件序列当中,此方法不会再被调用。
  • onTouchEvent方法在dispatchTouchEvent方法内部调用,用来处理点击事件,返回true则自己处理该事件,返回false则向上返回让其父容器处理(调用其自己的onTouchEvent方法)。如果不消耗,则在同一个事件序列中,当前View无法再次接收到事件(一个事件序列只能被同一个view处理)。

三个方法的关系可以用下面的伪代码表示:

public boolean dispatchTouchEvent(MotionEvent ev) {
    boolean consume = false;
    if (onInterceptTouchEvent(ev)) {
        consume = onTouchEvent(ev);
    } else {
        consume = child.dispatchTouchEvent(ev);
    }
    return consume;
}

View的事件分发体系有以下注意事项:

  • 当一个点击事件发生之后,传递过程遵循如下顺序:Activity->Window->View。如果一个View的onTouchEvent方法返回false,那么它的父容器的onTouchEvent方法将会被调用,依此类推,如果所有的元素都不处理这个事件,那么这个事件将会最终传递给Activity处理(调用Activity的onTouchEvent方法)。
  • 正常情况下,一个事件序列只能被一个View拦截并消耗,一旦某个View拦截了某个事件,那么同一个事件序列内的所有事件都会直接交给它处理,并且该元素的onInterceptTouchEvent方法不会被调用了。某个View一旦开始处理事件,如果它不消耗ACTION_DOWN事件,那么同一事件序列的其他事件都不会再交给它来处理,并且事件将重新交给它的父容器去处理(调用父容器的onTouchEvent方法);如果它消耗ACTION_DOWN事件,但是不消耗其他类型事件,那么这个点击事件会消失,父容器的onTouchEvent方法不会被调用,当前View依然可以收到后续的事件,但是这些事件最后都会传递给Activity处理。
  • ViewGroup默认不拦截任何事件,因为它的onInterceptTouchEvent方法默认返回false。View没有onInterceptTouchEvent方法,一旦有点击事件传递给它,那么它的onTouchEvent方法就会被调用。
  • View的onTouchEvent默认都会消耗事件(返回true),除非它是不可点击的(clickable和longClickable都为false)。View的longClickable默认是false的,clickable则不一定,Button默认是true,而TextView默认是false。
  • OnTouchListener的优先级比onTouchEvent要高:如果给一个View设置了OnTouchListener,那么OnTouchListener中的onTouch方法会被回调。这时事件如何处理还要看onTouch的返回值,如果返回false,那么当前View的onTouchEvent方法会被调用;否则onTouchEvent方法将不会被调用。在onTouchEvent方法中,如果当前View设置了OnClickListener,那么它的onClick方法会被调用,所以OnClickListener的优先级最低。
  • View的enable属性不影响onTouchEvent的默认返回值。哪怕一个View是disable状态,只要它的clickable或者longClickable有一个是true,那么它的onTouchEvent就会返回true。
  • 事件传递过程总是先传递给父元素,然后再由父元素分发给子View,通过requestDisallowInterceptTouchEvent方法可以在子元素中干预父元素的事件分发过程,但是ACTION_DOWN事件除外,即当面对ACTION_DOWN事件时,ViewGroup总是会调用自己的onInterceptTouchEvent方法来询问自己是否要拦截事件。ViewGroup的dispatchTouchEvent方法中有一个标志位FLAG_DISALLOW_INTERCEPT,这个标志位就是通过子View调用requestDisallowInterceptTouchEvent方法来设置的,一旦设置为true,那么ViewGroup不会拦截该事件。

View的滑动冲突

常见的滑动冲突的场景:

  1. 外部滑动方向和内部滑动方向不一致,例如ViewPager中包含listView;
  2. 外部滑动方向和内部滑动方向一致,例如ViewPager的单页中存在可以滑动的bannerView;
  3. 上面两种情况的嵌套,例如ViewPager的单个页面中包含了bannerView和listView。

滑动冲突处理规则:可以根据滑动距离和水平方向形成的夹角;或者根据水平和竖直方向滑动的距离差;或者两个方向上的速度差等,一般有以下解决方式

  1. 外部拦截法:点击事件都先经过父容器的拦截处理,如果父容器需要此事件就拦截,如果不需要就不拦截。该方法需要重写父容器的onInterceptTouchEvent方法,在内部做相应的拦截即可,其他均不需要做修改。伪码如下:
public boolean onInterceptTouchEvent(MotionEvent event) {
    boolean intercepted = false;
    int x = (int) event.getX();
    int y = (int) event.getY();

    switch (event.getAction()) {
        case MotionEvent.ACTION_DOWN: {
            intercepted = false;
            break;
        }
        case MotionEvent.ACTION_MOVE: {
            int deltaX = x - mLastXIntercept;
            int deltaY = y - mLastYIntercept;
            if (父容器需要拦截当前点击事件的条件,例如:Math.abs(deltaX) > Math.abs(deltaY)) {
                intercepted = true;
            } else {
                intercepted = false;
            }
            break;
        }
        case MotionEvent.ACTION_UP: {
            intercepted = false;
            break;
        }
        default:
            break;
    }

    mLastXIntercept = x;
    mLastYIntercept = y;
    return intercepted;
}
  1. 内部拦截法:父容器不拦截任何事件,所有的事件都传递给子元素,如果子元素需要此事件就直接消耗掉,否则就交给父容器来处理。这种方法和Android中的事件分发机制不一致,需要配合
    requestDisallowInterceptTouchEvent方法才能正常工作。
public boolean dispatchTouchEvent(MotionEvent event) {
    int x = (int) event.getX();
    int y = (int) event.getY();

    switch (event.getAction()) {
        case MotionEvent.ACTION_DOWN: {]
            getParent().requestDisallowInterceptTouchEvent(true);
            break;
        }
        case MotionEvent.ACTION_MOVE: {
            int deltaX = x - mLastX;
            int deltaY = y - mLastY;
            if (当前View需要拦截当前点击事件的条件,例如:Math.abs(deltaX) > Math.abs(deltaY)) {
                getParent().requestDisallowInterceptTouchEvent(false);
            }
            break;
        }
        case MotionEvent.ACTION_UP: {
            break;
        }
        default:
            break;
    }

    mLastX = x;
    mLastY = y;
    return super.dispatchTouchEvent(event);
}

注:Android开发艺术探索一书对这两种拦截法写了两个例子,感兴趣阅读源码看下,外部拦截法内部拦截法

3.10.3 View的滑动

常见的实现View的滑动的方式有三种:

  1. 通过View本身提供的scrollTo和scrollBy方法:操作简单,适合对View内容的滑动;
  2. 通过动画给View施加平移效果来实现滑动:操作简单,适用于没有交互的View和实现复杂的动画效果;
  3. 通过改变View的LayoutParams使得View重新布局从而实现滑动:操作稍微复杂,适用于有交互的View。

scrollTo和scrollBy方法只能改变View内容的位置而不能改变View在布局中的位置,scrollBy是基于当前位置的相对滑动,而scrollTo是基于所传参数的绝对滑动。通过View的getScrollX和getScrollY方法可以得到滑动的距离。

使用动画来移动View主要是操作View的translationX和translationY属性,既可以使用传统的View动画,也可以使用属性动画。使用动画还存在一个交互问题:在android3.0以前的系统上,View动画和属性动画,新位置均无法触发点击事件,同时,老位置仍然可以触发单击事件。从3.0开始,属性动画的单击事件触发位置为移动后的位置,View动画仍然在原位置。

弹性滑动

  • Scroller的工作原理:Scroller本身并不能实现View的滑动,它需要配合View的computeScroll方法才能完成弹性滑动的效果,它不断地让View重绘,而每一次重绘距滑动起始时间会有一个时间间隔,通过这个时间间隔
    Scroller就可以得出View的当前的滑动位置,知道了滑动位置就可以通过scrollTo方法来完成View的滑动。就这样,View的每一次重绘都会导致View进行小幅度的滑动,而多次的小幅度滑动就组成了弹性滑动。
  • 使用延时策略来实现弹性滑动,它的核心思想是通过发送一系列延时消息从而达到一种渐进式的效果,具体来说可以使用Handler的sendEmptyMessageDelayed(xxx)或View的postDelayed方法,也可以使用线程的sleep方法。

3.4.3 View的绘制流程

ViewRoot是连接WindowManager和DecorView的纽带,View的三大流程均通过ViewRoot来完成。ActivityThread中,Activity创建完成后,会将DecorView添加到Window中,同时创建ViewRootImpl对象,并建立两者的关联。

View的绘制流程是从ViewRoot的performTraversals方法开始,其会依次调用performMeasure、performLayout和performDraw三个方法,这三个方法分别完成顶级View的measure、layout和draw这三大流程。其中performMeasure方法中会调用measure方法,在measure方法中又会调用onMeasure方法,在onMeasure方法中会对所有的子元素进行measure过程,这个时候measure流程就从父容器传递到子元素了,这样就完成了一次measure过程,layout和draw的过程类似。

measure过程

measure过程决定了View的宽高,在几乎所有的情况下这个宽高都等同于View最终的宽高。

MeasureSpec

在View测量的时候,系统会将View的LayoutParams在父View的约束下转换成对应的MeasureSpec,然后再根据这个MeasureSpec来确定View测量后的宽高。对于DecorView,它的MeasureSpec由窗口的尺寸和其自身的LayoutParams来决定;对于普通View,它的MeasureSpec由父容器的MeasureSpec和自身的LayoutParams来共同决定。具体代码如下所示:

//ViewGroup.java
protected void measureChildWithMargins(View child, int parentWidthMeasureSpec, int widthUsed,
        int parentHeightMeasureSpec, int heightUsed) {
    final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();

    final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
            mPaddingLeft + mPaddingRight + lp.leftMargin + lp.rightMargin + widthUsed, lp.width);
    final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
            mPaddingTop + mPaddingBottom + lp.topMargin + lp.bottomMargin + heightUsed, lp.height);

    child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}
public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
    int specMode = MeasureSpec.getMode(spec);
    int specSize = MeasureSpec.getSize(spec);

    int size = Math.max(0, specSize - padding);

    int resultSize = 0;
    int resultMode = 0;

    switch (specMode) {
    case MeasureSpec.EXACTLY:
        if (childDimension >= 0) {
            resultSize = childDimension;
            resultMode = MeasureSpec.EXACTLY;
        } else if (childDimension == LayoutParams.MATCH_PARENT) {
            resultSize = size;
            resultMode = MeasureSpec.EXACTLY;
        } else if (childDimension == LayoutParams.WRAP_CONTENT) {
            resultSize = size;
            resultMode = MeasureSpec.AT_MOST;
        }
        break;

    case MeasureSpec.AT_MOST:
        if (childDimension >= 0) {
            resultSize = childDimension;
            resultMode = MeasureSpec.EXACTLY;
        } else if (childDimension == LayoutParams.MATCH_PARENT) {
            resultSize = size;
            resultMode = MeasureSpec.AT_MOST;
        } else if (childDimension == LayoutParams.WRAP_CONTENT) {
            resultSize = size;
            resultMode = MeasureSpec.AT_MOST;
        }
        break;

    case MeasureSpec.UNSPECIFIED:
        ....
    }
    return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
}

由上述代码,可知普通View的MeasureSpec的创建规则:

  • 当View采用固定宽高时,不管父容器的MeasureSpec是什么,View的MeasureSpec都是EXACTLY,并且大小是LayoutParams中的大小。
  • 当View的宽高是match_parent时,如果父View的模式是EXACTLY,那么该View也是EXACTLY,并且大小是父View的剩余空间;如果父View是AT_MOST,那么View也是AT_MOST,并且大小是不会超过父容器的剩余空间。
  • 当View的宽高是wrap_content时,View的模式总是AT_MOST,并且大小不超过父View的剩余空间。
measure过程

View的measure过程由其measure方法完成,该方法是一个final方法,其会调用onMeasure方法,我们看一下相关代码:

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
            getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
}
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;
}
protected int getSuggestedMinimumWidth() {
    return (mBackground == null) ? mMinWidth : max(mMinWidth, mBackground.getMinimumWidth());
}

getDefaultSize方法返回测量宽高,setMeasuredDimension方法会将其返回的测量宽高设置到系统。需要注意的是,自定义View的时候如果默认系统设置测量值的方法,那么wrap_content的作用效果跟match_parent一样,为什么?回看一下上面的总结,当view的布局宽高为wrap_content时,则specMode为AT_MOST,则测量尺寸为specSize,就是父容器的剩余可用尺寸,即match_parent的效果。

对于ViewGroup而言,它除了需要完成自己的measure过程外,还要完成其子View的measure过程。而由于不同的ViewGroup具有不同的布局特性,这就导致它们的测量细节不同,所以ViewGroup没有定义测量过程,而是由其具体子类来实现测量细节,这里我们看一下LinearLayout的onMeasure方法:

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    if (mOrientation == VERTICAL) {
        measureVertical(widthMeasureSpec, heightMeasureSpec);
    } else {
        measureHorizontal(widthMeasureSpec, heightMeasureSpec);
    }
}
void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {
    ...
    for (int i = 0; i < count; i++) {
        final View child = getVirtualChildAt(i);
        ...
        measureChildBeforeLayout(child, i, widthMeasureSpec, 0, heightMeasureSpec,
                                total == 0? mTotalLength : 0);

        if (oldHeight != Integer.MIN_VALUE) {
            lp.height = oldHeight;
        }

        final int childHeight = child.getMeasuredHeight();
        final int totalLength = mTotalLength;
        mTotalLength = Math.max(totalLength, totalLength + childHeight + lp.topMargin + lp.bottomMargin + getNextLocationOffset(child));
    }
}

从上面这段代码可以看出,LinearLayout会遍历每个子View并对每个子View执行measureChildBeforeLayout方法,这个方法会调用子元素的measure方法,这样子View就开始依次进入measure过程,并且通过mTotalLength这个变量来记录LinearLayout在竖直方向上的高度,每测量一个子元素,mTotalLength就会增加,增加的部分主要是子View的高度以及子View在竖直方向的margin等,当子元素测量完毕后,LinearLayout会测量自己的大小。

    mTotalLength += mPaddingTop + mPaddingBottom;
    int heigthSize = mTotalLength;
    heigthSize = Math.max(heightSize, getSuggestedMinimumHeight());
    int heightSizeAndState = resolveSizeAndState(heigthSize, heightMeasureSpec, 0);
    heigthSize = heigthSizeAndState & MEASURED_SIZE_MASK;
    ...
    setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState), heightSizeAndState);

对于vertical的LinearLayout而言,它在水平方向的测量过程遵循View的测量过程,在竖直方向上的测量过程则与View有所不同。具体来说,如果它的布局中高度采用的是match_parent或者具体数值,那么它的测量过程和View一致,即高度为specSize;如果采用的是wrap_content,那么它的高度是所有子View所占用的高度总和,但是仍然不能超过它的父容器的剩余空间,当然它的最终高度还要考虑其在竖直方向的padding,这个过程可以进一步看如下代码:

public static int resolveSizeAndState(int size, int measureSpec, int childMeasuredState) {
    final int specMode = MeasureSpec.getMode(measureSpec);
    final int specSize = MeasureSpec.getSize(measureSpec);
    final int result;
    switch (specMode) {
        case MeasureSpec.AT_MOST:
            if (specSize < size) {
                result = specSize | MEASURED_STATE_TOO_SMALL;
            } else {
                result = size;
            }
            break;
        case MeasureSpec.EXACTLY:
            result = specSize;
            break;
        case MeasureSpec.UNSPECIFIED:
        default:
            result = size;
    }
    return result | (childMeasuredState & MEASURED_STATE_MASK);
}

接下来我们看一下其measure子View的过程,其提供了一系列measureChild的方法,用来发起对子View的测量,将具体的measure过程委托给相关的子View:

protected void measureChild(View child, int parentWidthMeasureSpec, int parentHeightMeasureSpec) {
    final LayoutParams lp = child.getLayoutParams();
    final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec, mPaddingLeft + mPaddingRight, lp.width);
    final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec, mPaddingTop + mPaddingBottom, lp.height);
    child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}

简单概括一下整个流程:measure过程始于DecorView,通过不断遍历子View的measure方法,根据ViewGroup的MeasureSpec以及子View的LayoutParams来决定子View的MeasureSpec,从而获取子View的测量宽高,然后逐层返回。

需要注意的是:View的measure过程和Activity的生命周期方法不是同步执行的,因此无法保证Activity执行了onCreate、onStart、onResume时某个View已经测量完毕了。如果View还没有测量完毕,那么获得的宽高就都是0。以下是几种解决方法:

  • Activity/View#onWindowFocusChanged():onWindowFocusChanged方法表示View已经初始化完毕了,宽高已经准备好了,这个时候去获取宽高是没问题的。这个方法会被调用多次,当Activity继续执行或者暂停执行的时候,这个方法都会被调用。
  • View.post():通过post将一个runnable投递到消息队列的尾部,然后等待Looper调用此runnable的时候,View也已经初始化好了。
  • ViewTreeObserver:使用ViewTreeObserver的众多回调方法可以完成这个功能,比如使用onGlobalLayoutListener接口,当View树的状态发生改变或者View树内部的View的可见性发生改变时,onGlobalLayout方法将被回调。伴随着View树的状态改变,这个方法也会被多次调用。

layout过程

layout过程确定View在屏幕上的显示位置:即设置其left、top、right和bottom,这几个值构成的矩形区域就是该View显示的位置。一般由ViewGroup进行,当ViewGroup的位置确定以后,它在onLayout方法中会调用所有的子View的layout方法,递归进行,从而完成整个layout过程。这里我们仍然以LinearLayout为例看一下其layout过程,LinearLayout有横向和纵向布局,这里我们简要看一下纵向布局:

protected void onLayout(boolean changed, int l, int t, int r, int b) {
    if (mOrientation == VERTICAL) {
        layoutVertical(l, t, r, b);
    } else {
        layoutHorizontal(l, t, r, b);
    }
}
...
void layoutVertical(int left, int top, int right, int bottom) {
    final int paddingLeft = mPaddingLeft;
    int childTop;
    int childLeft;
    final int width = right - left;
    int childRight = width - mPaddingRight;
    //子View可用的宽度
    int childSpace = width - paddingLeft - mPaddingRight;
    //子View的数量
    final int count = getVirtualChildCount();
    //majorGravity是LinearLayout的android:gravity属性,即自己在父容器中的位置,垂直布局时,自己的gravity只能是vertical
    final int majorGravity = mGravity & Gravity.VERTICAL_GRAVITY_MASK;
    //minorGravity是LinearLayout中子View设置的gravity属性,接下来layout子组件时会用到,垂直布局时,子组件的gravity只能是horizontal
    final int minorGravity = mGravity & Gravity.RELATIVE_HORIZONTAL_GRAVITY_MASK;
    //确定顶部坐标
    switch (majorGravity) {
        //在父容器的底部,LinearLayout自己布局的顶部坐标=我距离顶部的距离+父容器的高度-我自身的高度
        case Gravity.BOTTOM:
            childTop = mPaddingTop + bottom - top - mTotalLength;
            break;
        // 在父容器的中间,顶部起点=我距离顶部的距离+(父容器高度-我的高度)/ 2
        case Gravity.CENTER_VERTICAL:
            childTop = mPaddingTop + (bottom - top - mTotalLength) / 2;
            break;
        //默认或者设置在父容器的顶部,顶部起点=我设置的距离顶部的距离
        case Gravity.TOP:
        default:
            childTop = mPaddingTop;
            break;
    }
    //上面的case也说明,垂直布局时,自己的位置属性在顶部,底部,还有垂直居中下才有效
    //递归布局子组件
    for (int i = 0; i < count; i++) {
        final View child = getVirtualChildAt(i);
        if (child == null) {
            childTop += measureNullChild(i);
        } else if (child.getVisibility() != GONE) {
            final int childWidth = child.getMeasuredWidth();
            final int childHeight = child.getMeasuredHeight();
            final LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) child.getLayoutParams();
            int gravity = lp.gravity;
            if (gravity < 0) {
                gravity = minorGravity;
            }
            final int layoutDirection = getLayoutDirection();
            final int absoluteGravity = Gravity.getAbsoluteGravity(gravity, layoutDirection);
            switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
                case Gravity.CENTER_HORIZONTAL:
                    childLeft = paddingLeft + ((childSpace - childWidth) / 2) + lp.leftMargin - lp.rightMargin;
                    break;
                case Gravity.RIGHT:
                    childLeft = childRight - childWidth - lp.rightMargin;
                    break;
                case Gravity.LEFT:
                default:
                    childLeft = paddingLeft + lp.leftMargin;
                    break;
            }
            //根据上面三个case分析,在Linearlayout垂直布局时,子组件的位置属性只有水平居中,居左,居右三个有效。
            if (hasDividerBeforeChildAt(i)) {
                childTop += mDividerHeight;
            }
            //计算子View的顶部坐标
            childTop += lp.topMargin;
            //设置子组件的位置
            setChildFrame(child, childLeft, childTop + getLocationOffset(child), childWidth, childHeight);
            //由于是纵向布局,因此子组件的顶部坐标应该是在上一个的基础上累加
            childTop += childHeight + lp.bottomMargin + getNextLocationOffset(child);
            i += getChildrenSkipCount(child, i);
        }
    }
}
private void setChildFrame(View child, int left, int top, int width, int height) {
    child.layout(left, top, left + width, top + height);
}

这个方法的整体过程可以分为三步:

  1. 根据容器的android:gravity属性计算第一个子View的顶部起始坐标(childTop);
  2. 遍历子View,根据子View的android:layout_gravity属性计算子View左边的坐标;
  3. 然后计算出子View顶部的坐标(vertical方向时,纵坐标是累加的,而横坐标每次都是从0开始),最后调用setChildFrame方法对子View进行layout。

同时我们可以知道:对于LinearLayout而言:

  • layout_gravity指的是自身在父容器的位置;gravity指的是子组件相对于自己的位置。当自身的layout_gravity和父容器对自己默认的gravity冲突时,优先选择自身的layout_gravity。
  • 当android:orientation="horizontal"时,自身的layout_gravity属性有效取值为:right,left,center_horizontal;子组件的layout_gravity有效取值为:top,bottom,center_vertical。当android:orientation="vertical"时,自身的layout_gravity属性有效取值为:top,bottom,center_vertical;子组件的layout_gravity有效取值为:left、right或者center_horizontal。

draw过程

draw过程决定了View的显示,其流程比较简单,一般分为以下几步:

  1. 绘制背景:background.draw(canvas);
  2. 绘制自己:onDraw();
  3. 绘制children:dispatchDraw;
  4. 绘制装饰:onDrawScrollBars。

3.4.4 自定义View

自定义View注意事项:

  1. 继承View需要支持wrap_content,并且处理padding,而继承特定的View例如TextView不需要考虑。
  2. View中如果有线程或者动画,需要在onDetachedFromWindow方法中及时停止。
  3. 处理好View的滑动冲突情况。

推荐阅读更多精彩内容