从源码解析Android中View的容器ViewGroup
这回我们是深入到viewgroup内部\，了解viewgroup的工作，同时会阐述更多有关于view的相关知识。以便为以后能灵活的使用自定义空间打更近一步的基础。希望有志同道合的朋友一起来探讨，深入android内部，深入理解android。
一、viewgroup是什么？
一个viewgroup是一个可以包含子view的容器，是布局文件和view容器的基类。在这个类里定义了viewgroup.layoutparams类，这个类是布局参数的子类。
其实viewgroup也就是view的容器。通过viewgroup.layoutparams来指定子view的参数。
viewgroup作为一个容器，为了制定这个容器应有的标准所以为其指定了接口
public abstract class viewgroup extends view implements viewparent, viewmanager
这两个接口这里不研究，如果涉及到的话会带一下。viewgroup有小4000行代码，下面我们一个模块一个模块分析。
二、viewgroup这个容器
viewgroup是一个容器，其采用一个数组来存储这些子view：
// child views of this viewgroup private view[] mchildren;
由于是通过一个数组来存储view数据的，所以对于viewgroup来说其必须实现增、删、查的算法。下面我们就来看看其内部实现。
2.1 添加view的算法
protected boolean addviewinlayout(view child, int index, layoutparams params) {
return addviewinlayout(child, index, params, false);
}
protected boolean addviewinlayout(view child, int index, layoutparams params,
boolean preventrequestlayout) {
child.mparent = null;
addviewinner(child, index, params, preventrequestlayout);
child.mprivateflags = (child.mprivateflags & ~dirty_mask) | drawn;
return true;
}
private void addviewinner(view child, int index, layoutparams params,
boolean preventrequestlayout) {
...
addinarray(child, index);
...
}
private void addinarray(view child, int index) {
...
}
上面四个方法就是添加view的核心算法的封装，它们是层层调用的关系。而我们通常调用的addview就是最终通过上面那个来最终达到添加到viewgroup中的。
2.1.1 我们先来分析addviewinner方法：
首先是对子view是否已经包含到一个父容器中，主要的防止添加一个已经有父容器的view，因为添加一个拥有父容器的view时会碰到各种问题。比如记录本身父容器算法的问题、本身被多个父容器包含时更新的处理等等一系列的问题都会出现。
if (child.getparent() != null) {
throw new illegalstateexception("the specified child already has a parent. " +
"you must call removeview() on the child's parent first.");
}
然后就是对子view布局参数的处理。
调用addinarray来添加view
父view为当前的viewgroup
焦点的处理。
当前view的attachinfo信息，这个信息是用来在窗口处理中用的。android的窗口系统就是用过attachinfo来判断view的所属窗口的，这个了解下就行。详细信息设计到android框架层的一些东西。
attachinfo ai = mattachinfo;
if (ai != null) {
boolean lastkeepon = ai.mkeepscreenon;
ai.mkeepscreenon = false;
child.dispatchattachedtowindow(mattachinfo, (mviewflags&visibility_mask));
if (ai.mkeepscreenon) {
needglobalattributesupdate(true);
}
ai.mkeepscreenon = lastkeepon;
}
view树改变的监听
if (monhierarchychangelistener != null) {
monhierarchychangelistener.onchildviewadded(this, child);
}
子view中的mviewflags的设置：
if ((child.mviewflags & duplicate_parent_state) == duplicate_parent_state) {
mgroupflags |= flag_notify_children_on_drawable_state_change;
}
2.1.2 addinarray
这个里面的实现主要是有个知识点，以前也没用过arraycopy，这里具体实现就不多加描述了。
system.arraycopy(children, 0, mchildren, 0, index); system.arraycopy(children, index, mchildren, index + 1, count - index);
2.2 移除view
移除view的几种方式：
（1）移除指定的view。
（2）移除从指定位置的view
（3）移除从指定位置开始的多个view
（4）移除所有的view
其中具体涉及到的方法就有好多了，不过最终对要删除的子view中所做的无非就是下列的事情：
如果拥有焦点则清楚焦点
将要删除的view从当前的window中解除关系。
设置view树改变的事件监听，我们可以通过监听onhierarchychangelistener事件来进行一些相应的处理。
从父容器的子容器数组中删除。
具体的内容这里就不一一贴出来了，大家回头看看源码就哦了。
2.3 查询
这个就简单了，就是直接从数组中取出就可以了：
public view getchildat(int index) {
try {
return mchildren[index];
} catch (indexoutofboundsexception ex) {
return null;
}
}
分析到这儿，其实我们已经相当于分析了viewgroup四分之一的代码了，呵呵。
三、onfinishinflate
我们一般使用view的流程是在oncreate中使用setcontentview来设置要显示layout文件或直接创建一个view，在当设置了contentview之后系统会对这个view进行解析，然后回调当前视图view中的onfinishinflate方法。只有解析了这个view我们才能在这个view容器中获取到拥有id的组件，同样因为系统解析完view之后才会调用onfinishinflate方法，所以我们自定义组件时可以onfinishinflate方法中获取指定子view的引用。
四、测量组件
在viewgroup中提供了测量子组件的三个方法。
1、measurechild(view, int, int)，为子组件添加padding
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);
}
2、measurechildren(int, int)根据指定的高和宽来测量所有子view中显示参数非gone的组件。
protected void measurechildren(int widthmeasurespec, int heightmeasurespec) {
final int size = mchildrencount;
final view[] children = mchildren;
for (int i = 0; i < size; ++i) {
final view child = children[i];
if ((child.mviewflags & visibility_mask) != gone) {
measurechild(child, widthmeasurespec, heightmeasurespec);
}
}
}
3、measurechildwithmargins(view, int, int, int, int)测量指定的子组件，为子组件添加padding和margin。
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);
}
上面三个方法都是为子组件设置了布局参数。最终调用的方法是子组件的measure方法。在view中我们知道这个调用实际上就是设置了子组件的布局参数并且调用onmeasure方法，最终设置了view测量后的高度和宽度。
五、onlayout
这个函数是一个抽象函数，要求实现viewgroup的函数必须实现这个函数，这也就是viewgroup是一个抽象函数的原因。因为各种组件实现的布局方式不一样，而onlayout是必须被重载的函数。
@override
protected abstract void onlayout(boolean changed,
int l, int t, int r, int b);
来看view中layout方法：
public final void layout(int l, int t, int r, int b) {
boolean changed = setframe(l, t, r, b);
if (changed || (mprivateflags & layout_required) == layout_required) {
if (viewdebug.trace_hierarchy) {
viewdebug.trace(this, viewdebug.hierarchytracetype.on_layout);
}
onlayout(changed, l, t, r, b);
mprivateflags &= ~layout_required;
}
mprivateflags &= ~force_layout;
}
在这个方法中调用了setframe方法，这个方法是用来设置view中的上下左右边距用的
protected boolean setframe(int left, int top, int right, int bottom) {
boolean changed = false;
//.......
if (mleft != left || mright != right || mtop != top || mbottom != bottom) {
changed = true;
// remember our drawn bit
int drawn = mprivateflags & drawn;
// invalidate our old position
invalidate();
int oldwidth = mright - mleft;
int oldheight = mbottom - mtop;
mleft = left;
mtop = top;
mright = right;
mbottom = bottom;
mprivateflags |= has_bounds;
int newwidth = right - left;
int newheight = bottom - top;
if (newwidth != oldwidth || newheight != oldheight) {
onsizechanged(newwidth, newheight, oldwidth, oldheight);
}
if ((mviewflags & visibility_mask) == visible) {
// if we are visible, force the drawn bit to on so that
// this invalidate will go through (at least to our parent).
// this is because someone may have invalidated this view
// before this call to setframe came in, therby clearing
// the drawn bit.
mprivateflags |= drawn;
invalidate();
}
// reset drawn bit to original value (invalidate turns it off)
mprivateflags |= drawn;
mbackgroundsizechanged = true;
}
return changed;
}
我们可以看到如果新的高度和宽度改变之后会调用重新设置view的四个参数：
（1）protected int mleft;
（2）protected int mright;
（3）protected int mtop;
（4）protected int mbottom;
这四个参数指定了view将要布局的位置。而绘制的时候是通过这四个参数来绘制，所以我们在view中调用layout方法可以实现指定子view中布局。
六、viewgroup的绘制。
viewgroup的绘制实际上是调用的dispatchdraw，绘制时需要考虑动画问题，而动画的实现实际上就通过dispatchdraw来实现的。
我们不用理会太多的细节，直接看其绘制子组件调用的是drawchild方法，这个里面具体的东西就多了，涉及到动画效果的处理，如果有机会的话再写，我们只要知道这个方法的功能就行。
这里有个demo贴出其中的代码大家可以测试下。
public viewgroup01(context context)
{
super(context);
button mbutton = new button(context);
mbutton.settext("测试");
addview(mbutton);
}
@override
protected void onlayout(boolean changed, int l, int t, int r, int b)
{
view v = getchildat(0);
if(v != null)
{
v.layout(120, 120, 250, 250);
}
}
@override
protected void dispatchdraw(canvas canvas)
{
super.dispatchdraw(canvas);
view v = getchildat(0);
if(v != null)
{
drawchild(canvas, v, getdrawingtime());
}
}
效果图片：
七、viewgroup的事件分发机制
我们用手指去触摸android手机屏幕，就会产生一个触摸事件，但是这个触摸事件在底层是怎么分发的呢？这个我还真不知道，这里涉及到操作硬件（手机屏幕）方面的知识，也就是linux内核方面的知识，我也没有了解过这方面的东西，所以我们可能就往上层来分析分析，我们知道android中负责与用户交互，与用户操作紧密相关的四大组件之一是activity, 所以我们有理由相信activity中存在分发事件的方法，这个方法就是dispatchtouchevent(),我们先看其源码吧
public boolean dispatchtouchevent(motionevent ev) {
//如果是按下状态就调用onuserinteraction()方法，onuserinteraction()方法
//是个空的方法, 我们直接跳过这里看下面的实现
if (ev.getaction() == motionevent.action_down) {
onuserinteraction();
}
if (getwindow().superdispatchtouchevent(ev)) {
return true;
}
//getwindow().superdispatchtouchevent(ev)返回false，这个事件就交给activity
//来处理， activity的ontouchevent()方法直接返回了false
return ontouchevent(ev);
}
这个方法中我们还是比较关心getwindow()的superdispatchtouchevent()方法，getwindow()返回当前activity的顶层窗口window对象，我们直接看window api的superdispatchtouchevent()方法
/** * used by custom windows, such as dialog, to pass the touch screen event * further down the view hierarchy. application developers should * not need to implement or call this. * */ public abstract boolean superdispatchtouchevent(motionevent event);
这个是个抽象方法，所以我们直接找到其子类来看看superdispatchtouchevent()方法的具体逻辑实现，window的唯一子类是phonewindow,我们就看看phonewindow的superdispatchtouchevent()方法
public boolean superdispatchtouchevent(keyevent event) {
return mdecor.superdispatctouchevent(event);
}
里面直接调用decorview类的superdispatchtouchevent()方法，或许很多人不了解decorview这个类，decorview是phonewindow的一个final的内部类并且继承framelayout的，也是window界面的最顶层的view对象，这是什么意思呢？别着急，我们接着往下看
我们先新建一个项目，取名androidtouchevent，然后直接用模拟器运行项目， mainactivity的布局文件为
<relativelayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".mainactivity" >
<textview
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerhorizontal="true"
android:layout_centervertical="true"
android:text="@string/hello_world" />
</relativelayout>
利用hierarchyviewer工具来查看下mainactivity的view的层次结构，如下图
我们看到最顶层就是phonewindow$decorview，接着decorview下面有一个linearlayout， linearlayout下面有两个framelayout
上面那个framelayout是用来显示标题栏的，这个demo中是一个textview,当然我们还可以定制我们的标题栏，利用getwindow().setfeatureint(window.feature_custom_title,r.layout.xxx); xxx就是我们自定义标题栏的布局xml文件
下面的framelayout是用来装载contentview的，也就是我们在activity中利用setcontentview()方法设置的view，现在我们知道了，原来我们利用setcontentview()设置activity的view的外面还嵌套了这么多的东西
我们来理清下思路，activity的最顶层窗体是phonewindow,而phonewindow的最顶层view是decorview，接下来我们就看decorview类的superdispatchtouchevent()方法
public boolean superdispatchtouchevent(motionevent event) {
return super.dispatchtouchevent(event);
}
在里面调用了父类framelayout的dispatchtouchevent()方法，而framelayout中并没有dispatchtouchevent()方法，所以我们直接看viewgroup的dispatchtouchevent()方法
/**
* {@inheritdoc}
*/
@override
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;
//这个值默认是false, 然后我们可以通过requestdisallowintercepttouchevent(boolean disallowintercept)方法
//来改变disallowintercept的值
boolean disallowintercept = (mgroupflags & flag_disallow_intercept) != 0;
//这里是action_down的处理逻辑
if (action == motionevent.action_down) {
//清除mmotiontarget, 每次action_down都很设置mmotiontarget为null
if (mmotiontarget != null) {
mmotiontarget = null;
}
//disallowintercept默认是false, 就看viewgroup的onintercepttouchevent()方法
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;
//遍历其子view
for (int i = count - 1; i >= 0; i--) {
final view child = children[i];
//如果该子view是visible或者该子view正在执行动画, 表示该view才
//可以接受到touch事件
if ((child.mviewflags & visibility_mask) == visible
|| child.getanimation() != null) {
//获取子view的位置范围
child.gethitrect(frame);
//如touch到屏幕上的点在该子view上面
if (frame.contains(scrolledxint, scrolledyint)) {
// offset the event to the view's coordinate system
final float xc = scrolledxfloat - child.mleft;
final float yc = scrolledyfloat - child.mtop;
ev.setlocation(xc, yc);
child.mprivateflags &= ~cancel_next_up_event;
//调用该子view的dispatchtouchevent()方法
if (child.dispatchtouchevent(ev)) {
// 如果child.dispatchtouchevent(ev)返回true表示
//该事件被消费了，设置mmotiontarget为该子view
mmotiontarget = child;
//直接返回true
return true;
}
// the event didn't get handled, try the next view.
// don't reset the event's location, it's not
// necessary here.
}
}
}
}
}
//判断是否为action_up或者action_cancel
boolean isuporcancel = (action == motionevent.action_up) ||
(action == motionevent.action_cancel);
if (isuporcancel) {
//如果是action_up或者action_cancel, 将disallowintercept设置为默认的false
//假如我们调用了requestdisallowintercepttouchevent()方法来设置disallowintercept为true
//当我们抬起手指或者取消touch事件的时候要将disallowintercept重置为false
//所以说上面的disallowintercept默认在我们每次action_down的时候都是false
mgroupflags &= ~flag_disallow_intercept;
}
// the event wasn't an action_down, dispatch it to our target if
// we have one.
final view target = mmotiontarget;
//mmotiontarget为null意味着没有找到消费touch事件的view, 所以我们需要调用viewgroup父类的
//dispatchtouchevent()方法，也就是view的dispatchtouchevent()方法
if (target == null) {
// we don't have a target, this means we're handling the
// event as a regular view.
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里面的代码action_down不会执行，只有action_move
//action_up才会走到这里, 假如在action_move或者action_up拦截的
//touch事件, 将action_cancel派发给target，然后直接返回true
//表示消费了此touch事件
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)) {
}
// clear the target
mmotiontarget = null;
// don't dispatch this event to our own view, because we already
// saw it when intercepting; we just want to give the following
// event to the normal ontouchevent().
return true;
}
if (isuporcancel) {
mmotiontarget = null;
}
// finally offset the event to the target's coordinate system and
// dispatch the event.
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;
}
//如果没有拦截action_move, action_down的话，直接将touch事件派发给target
return target.dispatchtouchevent(ev);
}
这个方法相对来说还是蛮长，不过所有的逻辑都写在一起，看起来比较方便，接下来我们就具体来分析一下
我们点击屏幕上面的textview来看看touch是如何分发的，先看看action_down
在decorview这一层会直接调用viewgroup的dispatchtouchevent(), 先看18行，每次action_down都会将mmotiontarget设置为null, mmotiontarget是什么？我们先不管，继续看代码，走到25行, disallowintercept默认为false，我们再看viewgroup的onintercepttouchevent()方法
public boolean onintercepttouchevent(motionevent ev) {
return false;
}
直接返回false, 继续往下看，循环遍历decorview里面的child，从上面的mainactivity的层次结构图我们可以看出，decorview里面只有一个child那就是linearlayout, 第43行判断touch的位置在不在linnearlayout上面，这是毫无疑问的，所以直接跳到51行， 调用linearlayout的dispatchtouchevent()方法，linearlayout也没有dispatchtouchevent()这个方法，所以也是调用viewgroup的dispatchtouchevent()方法，所以这个方法卡在51行没有继续下去，而是去先执行linearlayout的dispatchtouchevent()
linearlayout调用dispatchtouchevent()的逻辑跟decorview是一样的，所以也是遍历linearlayout的两个framelayout，判断touch的是哪个framelayout，很明显是下面那个，调用下面那个framelayout的dispatchtouchevent(), 所以linearlayout的dispatchtouchevent()卡在51也没继续下去
继续调用framelayout的dispatchtouchevent()方法，和上面一样的逻辑，下面的framelayout也只有一个child，就是relativelayout，framelayout的dispatchtouchevent()继续卡在51行，先执行relativelayout的dispatchtouchevent()方法
执行relativelayout的dispatchtouchevent()方法逻辑还是一样的，循环遍历 relativelayout里面的孩子，里面只有一个textview, 所以这里就调用textview的dispatchtouchevent()， textview并没有dispatchtouchevent()这个方法，于是找textview的父类view，在看view的dispatchtouchevent()的方法之前，我们先理清下上面这些viewgroup执行dispatchtouchevent()的思路，我画了一张图帮大家理清下（这里没有画出onintercepttouchevent（）方法）
下一篇： Java中的深拷贝和浅拷贝介绍