当前位置: 首页 > 编程笔记 >

深入理解Android中View绘制的三大流程

岳和泽
2023-03-14
本文向大家介绍深入理解Android中View绘制的三大流程,包括了深入理解Android中View绘制的三大流程的使用技巧和注意事项,需要的朋友参考一下

前言

最近对Android中View的绘制机制有了一些新的认识,所以想记录下来并分享给大家。View的工作流程主要是指measure、layout、draw这三大流程,即测量、布局和绘制,其中measure确定View的测量宽高,layout根据测量的宽高确定View在其父View中的四个顶点的位置,而draw则将View绘制到屏幕上,这样通过ViewGroup的递归遍历,一个View树就展现在屏幕上了。

说的简单,下面带大家一步一步从源码中分析:

Android的View是树形结构的:


基本概念

在介绍View的三大流程之前,我们必须先介绍一些基本的概念,才能更好地理解这整个过程。

Window的概念

Window表示的是一个窗口的概念,它是站在WindowManagerService角度上的一个抽象的概念,Android中所有的视图都是通过Window来呈现的,不管是Activity、Dialog还是Toast,只要有View的地方就一定有Window。

这里需要注意的是,这个抽象的Window概念和PhoneWindow这个类并不是同一个东西,PhoneWindow表示的是手机屏幕的抽象,它充当Activity和DecorView之间的媒介,就算没有PhoneWindow也是可以展示View的。

抛开一切,仅站在WindowManagerService的角度上,Android的界面就是由一个个Window层叠展现的,而Window又是一个抽象的概念,它并不是实际存在的,它是以View的形式存在,这个View就是DecorView。

关于Window这方面的内容,我们这里先了解一个大概

DecorView的概念

DecorView是整个Window界面的最顶层View,View的测量、布局、绘制、事件分发都是由DecorView往下遍历这个View树。DecorView作为顶级View,一般情况下它内部会包含一个竖直方向的LinearLayout,在这个LinearLayout里面有上下两个部分(具体情况和Android的版本及主题有关),上面是【标题栏】,下面是【内容栏】。在Activity中我们通过setContentView所设置的布局文件其实就是被加载到【内容栏】中的,而内容栏的id是content,因此指定布局的方法叫setContent().

ViewRoot的概念

ViewRoot对应于ViewRootImpl类,它是连接WindowManager和DecorView的纽带,View的三大流程均是通过ViewRoot来完成的。在ActivityThread中,当Activity对象被创建完之后,会讲DecorView添加到Window中,同时会创建对应的ViewRootImpl,并将ViewRootImpl和DecorView建立关联,并保存到WindowManagerGlobal对象中。

WindowManagerGlobal.java

root = new ViewRootImpl(view.getContext(), display); 
root.setView(view, wparams, panelParentView);

View的绘制流程是从ViewRoot的performTraversals方法开始的,它经过measure、layout和draw三个过程才能最终将一个View绘制出来,大致流程如下图:

Measure测量

为了更好地理解View的测量过程,我们还需要理解MeasureSpec,它是View的一个内部类,它表示对View的测量规格。MeasureSpec代表一个32位int值,高2位代表SpecMode(测量模式),低30位代表SpecSize(测量大小),我们可以看看它的具体实现:

MeasureSpec.java

public static class MeasureSpec { 
 private static final int MODE_SHIFT = 30;
 private static final int MODE_MASK = 0x3 << MODE_SHIFT;

 /**
  * UNSPECIFIED 模式:
  * 父View不对子View有任何限制,子View需要多大就多大
  */ 
 public static final int UNSPECIFIED = 0 << MODE_SHIFT;

 /**
  * EXACTYLY 模式:
  * 父View已经测量出子Viwe所需要的精确大小,这时候View的最终大小
  * 就是SpecSize所指定的值。对应于match_parent和精确数值这两种模式
  */ 
 public static final int EXACTLY = 1 << MODE_SHIFT;

 /**
  * AT_MOST 模式:
  * 子View的最终大小是父View指定的SpecSize值,并且子View的大小不能大于这个值,
  * 即对应wrap_content这种模式
  */ 
 public static final int AT_MOST = 2 << MODE_SHIFT;

 //将size和mode打包成一个32位的int型数值
 //高2位表示SpecMode,测量模式,低30位表示SpecSize,某种测量模式下的规格大小
 public static int makeMeasureSpec(int size, int mode) {
  if (sUseBrokenMakeMeasureSpec) {
  return size + mode;
  } else {
  return (size & ~MODE_MASK) | (mode & MODE_MASK);
  }
 }

 //将32位的MeasureSpec解包,返回SpecMode,测量模式
 public static int getMode(int measureSpec) {
  return (measureSpec & MODE_MASK);
 }

 //将32位的MeasureSpec解包,返回SpecSize,某种测量模式下的规格大小
 public static int getSize(int measureSpec) {
  return (measureSpec & ~MODE_MASK);
 }
 //...
 }

MeasureSpec通过将SpecMode和SpecSize打包成一个int值来避免过多的对象内存分配,并提供了打包和解包的方法。

SpecMode有三种类型,每一类都表示特殊的含义:

UNSPECIFIED

父容器不对View有任何限制,要多大就给多大,这种情况一般用于系统内部,表示一种测量的状态;

EXACTLY

父容器已经检测出View所需的精确大小,这个时候View的最终打消就是SpecSize所指定的值。它对应于LayoutParams中的match_parent和具体数值这两种模式。

AT_MOST

父容器指定了一个可用大小即SpecSize,View的大小不能大于这个值,具体是什么值要看不同View的具体实现。它对应于LayoutParams中wrap_content。

View的MeasureSpec是由父容器的MeasureSpec和自己的LayoutParams决定的,但是对于DecorView来说有点不同,因为它没有父类。在ViewRootImpl中的measureHierarchy方法中有如下一段代码展示了DecorView的MeasureSpec的创建过程,其中desiredWindowWidth和desireWindowHeight是屏幕的尺寸大小:

ViewGroup的measure

childWidthMeasureSpec = getRootMeasureSpec(desiredWindowWidth, lp.width); 
childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, lp.height); 
performMeasure(childWidthMeasureSpec, childHeightMeasureSpec); 

再看看getRootMeasureSpec方法:

 private static int getRootMeasureSpec(int windowSize, int rootDimension) {
 int measureSpec;
 switch (rootDimension) {

 case ViewGroup.LayoutParams.MATCH_PARENT:
  // Window can't resize. Force root view to be windowSize.
  measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.EXACTLY);
  break;
 case ViewGroup.LayoutParams.WRAP_CONTENT:
  // Window can resize. Set max size for root view.
  measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.AT_MOST);
  break;
 default:
  // Window wants to be an exact size. Force root view to be that size.
  measureSpec = MeasureSpec.makeMeasureSpec(rootDimension, MeasureSpec.EXACTLY);
  break;
 }
 return measureSpec;
 }

通过以上代码,DecorView的MeasureSpec的产生过程就很明确了,因为DecorView是FrameLyaout的子类,属于ViewGroup,对于ViewGroup来说,除了完成自己的measure过程外,还会遍历去调用所有子元素的measure方法,各个子元素再递归去执行这个过程。和View不同的是,ViewGroup是一个抽象类,他没有重写View的onMeasure方法,这里很好理解,因为每个具体的ViewGroup实现类的功能是不同的,如何测量应该让它自己决定,比如LinearLayout和RelativeLayout。

因此在具体的ViewGroup中需要遍历去测量子View,这里我们看看ViewGroup中提供的测量子View的measureChildWithMargins方法:

 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,在调用子元素的measure方法之前会先通过getChildMeasureSpec方法来得到子元素的MeasureSpec。从代码上看,子元素的MeasureSpec的创建与父容器的MeasureSpec和本身的LayoutParams有关,此外和View的margin和父类的padding有关,现在看看getChildMeasureSpec的具体实现:

ViewGroup.java

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) {
 // Parent has imposed an exact size on us
 case MeasureSpec.EXACTLY:
 if (childDimension >= 0) {
  resultSize = childDimension;
  resultMode = MeasureSpec.EXACTLY;
 } else if (childDimension == LayoutParams.MATCH_PARENT) {
  // Child wants to be our size. So be it.
  resultSize = size;
  resultMode = MeasureSpec.EXACTLY;
 } else if (childDimension == LayoutParams.WRAP_CONTENT) {
  // Child wants to determine its own size. It can't be
  // bigger than us.
  resultSize = size;
  resultMode = MeasureSpec.AT_MOST;
 }
 break;

 // Parent has imposed a maximum size on us
 case MeasureSpec.AT_MOST:
 if (childDimension >= 0) {
  // Child wants a specific size... so be it
  resultSize = childDimension;
  resultMode = MeasureSpec.EXACTLY;
 } else if (childDimension == LayoutParams.MATCH_PARENT) {
  // Child wants to be our size, but our size is not fixed.
  // Constrain child to not be bigger than us.
  resultSize = size;
  resultMode = MeasureSpec.AT_MOST;
 } else if (childDimension == LayoutParams.WRAP_CONTENT) {
  // Child wants to determine its own size. It can't be
  // bigger than us.
  resultSize = size;
  resultMode = MeasureSpec.AT_MOST;
 }
 break;

 // Parent asked to see how big we want to be
 case MeasureSpec.UNSPECIFIED:
 if (childDimension >= 0) {
  // Child wants a specific size... let him have it
  resultSize = childDimension;
  resultMode = MeasureSpec.EXACTLY;
 } else if (childDimension == LayoutParams.MATCH_PARENT) {
  // Child wants to be our size... find out how big it should
  // be
  resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
  resultMode = MeasureSpec.UNSPECIFIED;
 } else if (childDimension == LayoutParams.WRAP_CONTENT) {
  // Child wants to determine its own size.... find out how
  // big it should be
  resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
  resultMode = MeasureSpec.UNSPECIFIED;
 }
 break;
 }
 //noinspection ResourceType
 return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
}

上述代码根据父类的MeasureSpec和自身的LayoutParams创建子元素的MeasureSpec,具体过程同学们自行分析,最终的创建规则如下表:

ViewGroup在遍历完子View后,需要根据子元素的测量结果来决定自己最终的测量大小,并调用setMeasuredDimension方法保存测量宽高值。

setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),heightSizeAndState); 

这里调用了resolveSizeAndState来确定最终的大小,主要是保证测量的大小不能超过父容器的最大剩余空间maxWidth,这里我们看看它里面的实现:

 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);
 }

关于具体ViewGroup的onMeasure过程这里不做分析,由于每种布局的测量方式不一样,不可能逐个分析,但在它们的onMeasure里面的步骤是有一定规律的:

      1.根据各自的测量规则遍历Children元素,调用getChildMeasureSpec方法得到Child的measureSpec;

      2.调用Child的measure方法;

      3.调用setMeasuredDimension确定最终的大小。

View的measure

View的measure过程由其measure方法来完成,measure方法是一个final类型的方法,这意味着子类不能重写此方法,在View的measure方法里面会去调用onMeasure方法,我们这里只要看onMeasure的实现即可,如下:

View.java

 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
 setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
  getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
 }

代码很简单,我们继续看看getDefaultSize方法的实现:

View.java

 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;
 }

从上述代码可以得出,View的宽/高由specSize决定,直接继承View的自定义控件需要重写onMeasure方法并设置wrap_content时的自身大小,否则在布局中使用wrap_content就相当于使用match_parent

上述就是View的measure大致过程,在measure完成之后,通过getMeasuredWidth/Height方法就可以获得测量后的宽高,这个宽高一般情况下就等于View的最终宽高了,因为View的layout布局的时候就是根据measureWidth/Height来设置宽高的,除非在layout中修改了measure值。

Layout布局

Layout的作用是ViewGroup用来确定子元素的位置,当ViewGroup的位置被确定后,它在onLayout中会遍历所有的子元素并调用其layout方法。简单的来说就是,layout方法确定View本身的位置,而onLayout方法则会确定所有子元素的位置。

先看看View的layout方法:

 public void layout(int l, int t, int r, int b) {
  if ((mPrivateFlags3 & PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT) != 0) {
   onMeasure(mOldWidthMeasureSpec, mOldHeightMeasureSpec);
   mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
  }

  int oldL = mLeft;
  int oldT = mTop;
  int oldB = mBottom;
  int oldR = mRight;

  boolean changed = isLayoutModeOptical(mParent) ?
    setOpticalFrame(l, t, r, b) : setFrame(l, t, r, b);

  if (changed || (mPrivateFlags & PFLAG_LAYOUT_REQUIRED) == PFLAG_LAYOUT_REQUIRED) {
   onLayout(changed, l, t, r, b);

   if (shouldDrawRoundScrollbar()) {
    if(mRoundScrollbarRenderer == null) {
     mRoundScrollbarRenderer = new RoundScrollbarRenderer(this);
    }
   } else {
    mRoundScrollbarRenderer = null;
   }

   mPrivateFlags &= ~PFLAG_LAYOUT_REQUIRED;

   ListenerInfo li = mListenerInfo;
   if (li != null && li.mOnLayoutChangeListeners != null) {
    ArrayList<OnLayoutChangeListener> listenersCopy =
      (ArrayList<OnLayoutChangeListener>)li.mOnLayoutChangeListeners.clone();
    int numListeners = listenersCopy.size();
    for (int i = 0; i < numListeners; ++i) {
     listenersCopy.get(i).onLayoutChange(this, l, t, r, b, oldL, oldT, oldR, oldB);
    }
   }
  }

  mPrivateFlags &= ~PFLAG_FORCE_LAYOUT;
  mPrivateFlags3 |= PFLAG3_IS_LAID_OUT;
 }

主要看到这里:

boolean changed = isLayoutModeOptical(mParent) ?setOpticalFrame(l, t, r, b) : setFrame(l, t, r, b); 

isLayoutModeOptical方法判断是否显示边界布局(这个东西不知道是啥,暂时不理会),setOpticalFrame方法内部最终也是调用setFrame方法,这里我们看setFrame方法就可以了:

 protected boolean setFrame(int left, int top, int right, int bottom) {
  boolean changed = false;

  if (DBG) {
   Log.d("View", this + " View.setFrame(" + left + "," + top + ","
  + right + "," + bottom + ")");
  }
  //1、如果有一个值发生了改变,那么就需要重新调用onLayout方法了,后面会分析到
  if (mLeft != left || mRight != right || mTop != top || mBottom != bottom) {
   changed = true;

   // Remember our drawn bit
   int drawn = mPrivateFlags & PFLAG_DRAWN;

   //2、保存旧的宽和高
   int oldWidth = mRight - mLeft;
   int oldHeight = mBottom - mTop;
   //计算新的宽和高
   int newWidth = right - left;
   int newHeight = bottom - top;
   //3、判断宽高是否有分生变化
   boolean sizeChanged = (newWidth != oldWidth) || (newHeight != oldHeight);

   //Invalidate our old position
   //4、如果大小变化了,在已绘制了的情况下就请求重新绘制
   invalidate(sizeChanged);

   //5、存储新的值
   mLeft = left;
   mTop = top;
   mRight = right;
   mBottom = bottom;
   mRenderNode.setLeftTopRightBottom(mLeft, mTop, mRight, mBottom);

   mPrivateFlags |= PFLAG_HAS_BOUNDS;

   if (sizeChanged) {
   //6、大小变化时进行处理
   sizeChange(newWidth, newHeight, oldWidth, oldHeight);
   }

   if ((mViewFlags & VISIBILITY_MASK) == VISIBLE || mGhostView != null) {
   //7、如果此时View是可见状态下,立即执行绘制操作
   invalidate(sizeChanged);

   }

   mPrivateFlags |= drawn;

   mBackgroundSizeChanged = true;
   if (mForegroundInfo != null) {
   mForegroundInfo.mBoundsChanged = true;
   }

   notifySubtreeAccessibilityStateChangedIfNeeded();
  }
  return changed;
 }
  • 首先判断四个顶点的位置是否有变化;
  • 判断宽高是否有变化,如果变化了则请求重新绘制;
  • 保存新的值TOP、LEFT、BOTTOM、RIGHT。

可以看到changed的值只与四个点是否发生了变化有关。同时,我们还发现,在setframe方法后,就可以获得某个view的top、left、right、bottom的值了。

回到layout方法中,继续执行会调用onLayout方法,我们看看其代码:

protected void onLayout(boolean changed, int left, int top, int right, int bottom) {} 

可以看到这是一个空实现,和onMeasure方法类似,onLayout的实现和具体的布局有关,具体ViewGroup的子类需要重写onLayout方法,并根据具体布局规则遍历调用Children的layout方法。

通过上面的分析,可以得到两个结论:

  • View通过layout方法来确认自己在父容器中的位置
  • ViewGroup通过onLayout 方法来确定View在容器中的位置

接下来我们看看FrameLayout的onLayout方法是怎么实现的:

 @Override
 protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
  layoutChildren(left, top, right, bottom, false /* no force left gravity */);
 }

 void layoutChildren(int left, int top, int right, int bottom, boolean forceLeftGravity) {
  final int count = getChildCount();

  final int parentLeft = getPaddingLeftWithForeground();
  final int parentRight = right - left - getPaddingRightWithForeground();

  final int parentTop = getPaddingTopWithForeground();
  final int parentBottom = bottom - top - getPaddingBottomWithForeground();

  for (int i = 0; i < count; i++) {
   final View child = getChildAt(i);
   if (child.getVisibility() != GONE) {
    final LayoutParams lp = (LayoutParams) child.getLayoutParams();

    final int width = child.getMeasuredWidth();
    final int height = child.getMeasuredHeight();

    int childLeft;
    int childTop;

    int gravity = lp.gravity;
    if (gravity == -1) {
     gravity = DEFAULT_CHILD_GRAVITY;
    }

    final int layoutDirection = getLayoutDirection();
    final int absoluteGravity = Gravity.getAbsoluteGravity(gravity, layoutDirection);
    final int verticalGravity = gravity & Gravity.VERTICAL_GRAVITY_MASK;

    switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
     case Gravity.CENTER_HORIZONTAL:
      childLeft = parentLeft + (parentRight - parentLeft - width) / 2 +
      lp.leftMargin - lp.rightMargin;
      break;
     case Gravity.RIGHT:
      if (!forceLeftGravity) {
       childLeft = parentRight - width - lp.rightMargin;
       break;
      }
     case Gravity.LEFT:
     default:
      childLeft = parentLeft + lp.leftMargin;
    }

    switch (verticalGravity) {
     case Gravity.TOP:
      childTop = parentTop + lp.topMargin;
      break;
     case Gravity.CENTER_VERTICAL:
      childTop = parentTop + (parentBottom - parentTop - height) / 2 +
      lp.topMargin - lp.bottomMargin;
      break;
     case Gravity.BOTTOM:
      childTop = parentBottom - height - lp.bottomMargin;
      break;
     default:
      childTop = parentTop + lp.topMargin;
    }

    child.layout(childLeft, childTop, childLeft + width, childTop + height);
   }
  }
 }

1、获取父View的内边距padding的值

2、遍历子View,处理子View的layout_gravity属性、根据View测量后的宽和高、父View的padding值、来确定子View的布局参数,

3、调用child.layout方法,对子View进行布局

draw绘制

Draw过程就比较简单了,它的作用是将View绘制到屏幕上面。View的绘制过程遵循如下几部:

  • 绘制背景background.draw(canvas);
  • 绘制自己onDraw;
  • 绘制children:dispatchDraw;
  • 绘制装饰onDrawForeground;

这里我们看看draw方法:

 public void draw(Canvas canvas) {
  final int privateFlags = mPrivateFlags;
  final boolean dirtyOpaque = (privateFlags & PFLAG_DIRTY_MASK) == PFLAG_DIRTY_OPAQUE &&
    (mAttachInfo == null || !mAttachInfo.mIgnoreDirtyState);
  mPrivateFlags = (privateFlags & ~PFLAG_DIRTY_MASK) | PFLAG_DRAWN;

  /*
   * Draw traversal performs several drawing steps which must be executed
   * in the appropriate order:
   *
   *  1. Draw the background
   *  2. If necessary, save the canvas' layers to prepare for fading
   *  3. Draw view's content
   *  4. Draw children
   *  5. If necessary, draw the fading edges and restore layers
   *  6. Draw decorations (scrollbars for instance)
   */

  // Step 1, draw the background, if needed
  int saveCount;

  if (!dirtyOpaque) {
   drawBackground(canvas);
  }

  // skip step 2 & 5 if possible (common case)
  final int viewFlags = mViewFlags;
  boolean horizontalEdges = (viewFlags & FADING_EDGE_HORIZONTAL) != 0;
  boolean verticalEdges = (viewFlags & FADING_EDGE_VERTICAL) != 0;
  if (!verticalEdges && !horizontalEdges) {
   // Step 3, draw the content
   if (!dirtyOpaque) onDraw(canvas);

   // Step 4, draw the children
   dispatchDraw(canvas);

   // Overlay is part of the content and draws beneath Foreground
   if (mOverlay != null && !mOverlay.isEmpty()) {
    mOverlay.getOverlayView().dispatchDraw(canvas);
   }

   // Step 6, draw decorations (foreground, scrollbars)
   onDrawForeground(canvas);

   // we're done...
   return;
  }

   ... ...

 }

View的绘制过程的传递是通过dispatchDraw来实现的,dispatchDraw会遍历调用所有子元素的draw方法,如此draw事件就一层层地传递了下去。

总结

到这里,View的measure、layout、draw三大流程就说完了,这里做一下总结:

如果是自定义ViewGroup的话,需要重写onMeasure方法,在onMeasure方法里面遍历测量子元素,同理onLayout方法也是一样,最后实现onDraw方法绘制自己;

如果自定义View的话,则需要从写onMeasure方法,处理wrap_content的情况,不需要处理onLayout,最后实现onDraw方法绘制自己;

好了,以上就是这篇文章的全部内容,希望本文的内容对大家的学习或者工作能带来一定的帮助,如果有疑问大家可以留言交流,谢谢大家对小牛知识库的支持。

引用[Android开发艺术探索]

 类似资料:
  • 本文向大家介绍Android View 绘制流程(Draw)全面解析,包括了Android View 绘制流程(Draw)全面解析的使用技巧和注意事项,需要的朋友参考一下 前言 前几篇文章,笔者分别讲述了DecorView,measure,layout流程等,接下来将详细分析三大工作流程的最后一个流程——绘制流程。测量流程决定了View的大小,布局流程决定了View的位置,那么绘制流程将决定Vie

  • 本文向大家介绍Android View 绘制机制的详解,包括了Android View 绘制机制的详解的使用技巧和注意事项,需要的朋友参考一下 View 绘制机制一、 View 树的绘图流程 当 Activity 接收到焦点的时候,它会被请求绘制布局,该请求由 Android framework 处理.绘制是从根节点开始,对布局树进行 measure 和 draw。整个 View 树的绘图流程在V

  • 本文向大家介绍Android视图的绘制流程(上) View的测量,包括了Android视图的绘制流程(上) View的测量的使用技巧和注意事项,需要的朋友参考一下 综述   View的绘制流程可以分为三大步,它们分别是measure,layout和draw过程。measure表示View的测量过程,用于测量View的宽度和高度;layout用于确定View在父容器的位置;draw则是负责将View

  • 安卓(Android)是一种基于 Linux 内核(不包含 GNU 组件)的自由及开放源代码的操作系统。主要使用于移动设备,如智能手机和平板电脑,由美国 Google 公司和开放手机联盟领导及开发。

  • 本文向大家介绍深入理解Android 5.0中的Toolbar,包括了深入理解Android 5.0中的Toolbar的使用技巧和注意事项,需要的朋友参考一下 环境说明: Android Studio 2.0 V7包版本:com.android.support:appcompat-v7:23.4.0 compileSdkVersion 23 buildToolsVersion "24.0.0" T

  • 整个View树的绘图流程是在ViewRootImpl类的performTraversals()方法(这个方法巨长)开始的,该函数做的执行过程主要是根据之前设置的状态,判断是否重新计算视图大小(measure)、是否重新放置视图的位置(layout)、以及是否重绘 (draw)。 Measure 通过上面可以看出measure过程主要就是从顶层父View向子View递归调用view.measure方