13 Questions and 13 Answers Full Learn Android View Drawing

//These two parameters of desire represent the width and height of the screen. childWidthMeasureSpec = getRootMeasureSpec(desiredWindowWidth, );
 childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, );
 performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);



 //The measureSpec of decorView is determined here, but it is actually much simpler than the measurespec of ordinary view //The code will not be analyzed. Something can be seen at a glance private static int getRootMeasureSpec(int windowSize, int rootDimension) {
  int measureSpec;
  switch (rootDimension) {

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

//For the measurement of an ordinary view, it is triggered by the parent view of this view, that is, the viewgroup.//This is the following measureChildWithMargins method
protected void measureChildWithMargins(View child,
   int parentWidthMeasureSpec, int widthUsed,
   int parentHeightMeasureSpec, int heightUsed) {
   //Step 1: Get the layoutParams parameter value of the subview first  final MarginLayoutParams lp = (MarginLayoutParams) ();

  //Then start calculating the spec value of the subview. Note that when calculating, in addition to using the layoutparams parameter of the subview, the calculation is performed.  //The value of the parent view, that is, the viewgroup's own spec is also used.  final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
    mPaddingLeft + mPaddingRight +  + 
      + widthUsed, );
  final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
    mPaddingTop + mPaddingBottom +  + 
      + heightUsed, );

  (childWidthMeasureSpec, childHeightMeasureSpec);
}






//This method of calculating the spec of the view looks like a lot of things, but the logic is really very simple. It is based on the father's viewgroup//The meaurespec also has the view of its own params to determine the view of its own measureSpec.//Note that the parameter here is padding, the meaning of this value is the size of the control occupied by the parent container, so the Specsize of the viewThe value of // You can see that the value of this padding is to be subtracted.  Total size - already used = available.  Very easy to understand.
//Then you need to sort out the following switch logic clearly.  Actually, it is not difficult, mainly the following principles//If the view uses a fixed width and height, that is, the type of numerical value that is written.  Then regardless of the value of the father's spec, the spec of the view must be exactly and the size follows the size set in the layout parameter.
//If the width and height of the view are match_parent, then it depends on the spec value of the parent container viewgroup. If the spec of the parent view is exactly mode,//The view must be exactly, and the size is the remaining space in the parent container.  If the parent container is at_most mode, then the view is at_most and will not exceed the remaining space size
//If the width and height of the view are wrap_content, then regardless of the spec of the parent container, the spec of the view must be at_most and will not exceed the size of the remaining space of the parent view.

public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
  int specMode = (spec);
  int specSize = (spec);

  int size = (0, specSize - padding);

  int resultSize = 0;
  int resultMode = 0;

  switch (specMode) {
  // Parent has imposed an exact size on us
  case :
   if (childDimension >= 0) {
    resultSize = childDimension;
    resultMode = ;
   } else if (childDimension == LayoutParams.MATCH_PARENT) {
    // Child wants to be our size. So be it.
    resultSize = size;
    resultMode = ;
   } 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 = ;
   } 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 :
   if (childDimension >= 0) {
    // Child wants a specific size... let him have it
    resultSize = childDimension;
    resultMode = ;
   } else if (childDimension == LayoutParams.MATCH_PARENT) {
    // Child wants to be our size... find out how big it should
    // be
    resultSize =  ? 0 : size;
    resultMode = ;
   } else if (childDimension == LayoutParams.WRAP_CONTENT) {
    // Child wants to determine its own size.... find out how
    // big it should be
    resultSize =  ? 0 : size;
    resultMode = ;
   }
   break;
  }
  return (resultSize, resultMode);
 } 

//The measure of view is final method Our subclass cannot be modified. public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
  boolean optical = isLayoutModeOptical(this);
  if (optical != isLayoutModeOptical(mParent)) {
   Insets insets = getOpticalInsets();
   int oWidth =  + ;
   int oHeight =  + ;
   widthMeasureSpec = (widthMeasureSpec, optical ? -oWidth : oWidth);
   heightMeasureSpec = (heightMeasureSpec, optical ? -oHeight : oHeight);
  }

  // Suppress sign extension for the low bytes
  long key = (long) widthMeasureSpec << 32 | (long) heightMeasureSpec & 0xffffffffL;
  if (mMeasureCache == null) mMeasureCache = new LongSparseLongArray(2);

  if ((mPrivateFlags & PFLAG_FORCE_LAYOUT) == PFLAG_FORCE_LAYOUT ||
    widthMeasureSpec != mOldWidthMeasureSpec ||
    heightMeasureSpec != mOldHeightMeasureSpec) {

   // first clears the measured dimension flag
   mPrivateFlags &= ~PFLAG_MEASURED_DIMENSION_SET;

   resolveRtlPropertiesIfNeeded();

   int cacheIndex = (mPrivateFlags & PFLAG_FORCE_LAYOUT) == PFLAG_FORCE_LAYOUT ? -1 :
     (key);
   if (cacheIndex < 0 || sIgnoreMeasureCache) {
    // measure ourselves, this should set the measured dimension flag back
    onMeasure(widthMeasureSpec, heightMeasureSpec);
    mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
   } else {
    long value = (cacheIndex);
    // Casting a long to int drops the high 32 bits, no mask needed
    setMeasuredDimensionRaw((int) (value >> 32), (int) value);
    mPrivateFlags3 |= PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
   }

   // flag not set, setMeasuredDimension() was not invoked, we raise
   // an exception to warn the developer
   if ((mPrivateFlags & PFLAG_MEASURED_DIMENSION_SET) != PFLAG_MEASURED_DIMENSION_SET) {
    throw new IllegalStateException("View with id " + getId() + ": "
      + getClass().getName() + "#onMeasure() did not set the"
      + " measured dimension by calling"
      + " setMeasuredDimension()");
   }

   mPrivateFlags |= PFLAG_LAYOUT_REQUIRED;
  }

  mOldWidthMeasureSpec = widthMeasureSpec;
  mOldHeightMeasureSpec = heightMeasureSpec;

  (key, ((long) mMeasuredWidth) << 32 |
    (long) mMeasuredHeight & 0xffffffffL); // suppress sign extension
 }

//However, you can see that the onMeasure method is called in the measure method//So you can know that when we customize the view, we must rewrite this method! protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
    getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
 }

//You can see that this is the call of the setMeasuredDimension method. This method can be determined by the name of the view.//So the focus of our analysis is to see how the getDefaultSize method determines the measured width and height of the view. protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
    getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
 }


//This method is very simple. It can basically be considered to be an approximate return specSize in the spec, unless your specMode is UNSPECIFIED//UNSPECIFIED This is usually used for internal measurement of the system. In this case, the size is returned, which is the return value of getSuggestedMinimumWidth. public static int getDefaultSize(int size, int measureSpec) {
  int result = size;
  int specMode = (measureSpec);
  int specSize = (measureSpec);

  switch (specMode) {
  case :
   result = size;
   break;
  case MeasureSpec.AT_MOST:
  case :
   result = specSize;
   break;
  }
  return result;
}

//Related to the background of the view. I won't do much analysis hereprotected int getSuggestedMinimumWidth() {
  return (mBackground == null) ? mMinWidth : max(mMinWidth, ());
 } 

//Rewrite the activity methodpublic void onWindowFocusChanged(boolean hasFocus) {
  (hasFocus);
  if (hasFocus) {
   int width = ();
   int height = ();
   ("burning", "width==" + width);
   ("burning", "height==" + height);

  }
 }

@Override
 protected void onStart() {
  ();
  (new Runnable() {
   @Override
   public void run() {
    int width = ();
    int height = ();
   }
  });
 }

@Override
 protected void onStart() {
  ();
  ViewTreeObserver observer = ();
  (new () {
   @Override
   public void onGlobalLayout() {
    int width = ();
    int height = ();
    ().removeOnGlobalLayoutListener(this);
   }
  });
 }

/**
  * If this view doesn't do any drawing on its own, set this flag to
  * allow further optimizations. By default, this flag is not set on
  * View, but could be set on some View subclasses such as ViewGroup.
  *
  * Typically, if you override {@link #onDraw()}
  * you should clear this flag.
  *
  * @param willNotDraw whether or not this View draw on its own
  */
 public void setWillNotDraw(boolean willNotDraw) {
  setFlags(willNotDraw ? WILL_NOT_DRAW : 0, DRAW_MASK);
 }

package ;

import ;
import ;
import ;
import ;
import ;
import ;

/**
 * Created by Administrator on 2016/2/4.
 */
public class CircleView extends View {

 private int mColor = ;
 private Paint mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);

 private void init() {
  (mColor);
 }

 @Override
 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  (widthMeasureSpec, heightMeasureSpec);
  int widthSpecMode = (widthMeasureSpec);
  int widthSpecSize = (widthMeasureSpec);
  int heightSpecMode = (heightMeasureSpec);
  int heightSpecSize = (heightMeasureSpec);

  //The situation when it is handled as wrap_content  if (widthSpecMode == MeasureSpec.AT_MOST && heightSpecMode == MeasureSpec.AT_MOST) {
   setMeasuredDimension(200, 200);
  } else if (widthSpecMode == MeasureSpec.AT_MOST) {
   setMeasuredDimension(200, heightSpecSize);
  } else if (heightSpecMode == MeasureSpec.AT_MOST) {
   setMeasuredDimension(widthSpecSize, 200);
  }

 }

 @Override
 protected void onDraw(Canvas canvas) {
  (canvas);
  // Handle padding situation  final int paddingLeft = getPaddingLeft();
  final int paddingRight = getPaddingRight();
  final int paddingTop = getPaddingTop();
  final int paddingBottom = getPaddingBottom();


  int width = getWidth() - paddingLeft - paddingRight;
  int height = getHeight() - paddingTop - paddingBottom;
  int radius = (width, height) / 2;
  (paddingLeft + width / 2, paddingTop + height / 2, radius, mPaint);
 }

 public CircleView(Context context, AttributeSet attrs, int defStyleAttr) {
  super(context, attrs, defStyleAttr);
  init();
 }

 public CircleView(Context context) {
  super(context);
  init();

 }

 public CircleView(Context context, AttributeSet attrs) {
  super(context, attrs);
  init();
 }
}

package ;

import ;
import ;
import ;
import ;
import ;

/**
 * Created by Administrator on 2016/2/4.
 */
//Here we only deal with the padding state. The state of margin is not processed. The impact of margin of subview on measure and layout//It's left to the readers to complete it themselvespublic class CustomHorizontalLayout extends ViewGroup {

 //Set the minimum default control. Custom attributes are not provided here. Write them in the code. You can expand them yourself. final int minHeight = 0;
 final int minWidth = 0;


 public CustomHorizontalLayout(Context context) {
  super(context);
 }

 public CustomHorizontalLayout(Context context, AttributeSet attrs) {
  super(context, attrs);
 }

 public CustomHorizontalLayout(Context context, AttributeSet attrs, int defStyleAttr) {
  super(context, attrs, defStyleAttr);
 }

 @Override
 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  (widthMeasureSpec, heightMeasureSpec);
  int measureWidth = 0;
  int measureHeight = 0;
  final int childCount = getChildCount();
  measureChildren(widthMeasureSpec, heightMeasureSpec);
  int widthSpecMode = (widthMeasureSpec);
  int widthSpecSize = (widthMeasureSpec);
  int heightSpecMode = (heightMeasureSpec);
  int heightSpecSize = (heightMeasureSpec);
  final View childView = getChildAt(0);
  final int paddingLeft = getPaddingLeft();
  final int paddingRight = getPaddingRight();
  final int paddingTop = getPaddingTop();
  final int paddingBottom = getPaddingBottom();
  //When there are no child controls, our width and height need to be handled specially  if (childCount == 0) {
   //When there is no child control, if there is a wrap in length and width, then let the control be displayed in the smallest form   // Here we set it to 0 at least   if (widthSpecMode == MeasureSpec.AT_MOST || heightSpecMode == MeasureSpec.AT_MOST) {
    setMeasuredDimension(minWidth, minHeight);
   } else {
    //Otherwise, according to our layout attribute    setMeasuredDimension(getLayoutParams().width, getLayoutParams().height);
   }

  } else if (widthSpecMode == MeasureSpec.AT_MOST && heightSpecMode == MeasureSpec.AT_MOST) {
   measureWidth = () * childCount;
   measureHeight = ();
   setMeasuredDimension(paddingLeft + measureWidth + paddingRight, paddingTop + measureHeight + paddingBottom);
  } else if (heightSpecMode == MeasureSpec.AT_MOST) {
   measureHeight = ();
   setMeasuredDimension(paddingLeft + paddingRight + widthSpecSize, paddingTop + paddingBottom + measureHeight);
  } else if (widthSpecMode == MeasureSpec.AT_MOST) {
   measureWidth = () * childCount;
   setMeasuredDimension(paddingLeft + paddingRight + measureWidth, paddingTop + paddingBottom + heightSpecSize);
  }
 }

 @Override
 protected void onLayout(boolean changed, int l, int t, int r, int b) {
  final int paddingLeft = getPaddingLeft();
  final int paddingRight = getPaddingRight();
  final int paddingTop = getPaddingTop();
  final int paddingBottom = getPaddingBottom();
  //The initial position on the left is 0  int childLeft = 0 + paddingLeft;
  final int childCount = getChildCount();
  for (int i = 0; i < childCount; i++) {
   final View childView = getChildAt(i);
   if (() != ) {
    final int childWidth = ();
    (childLeft, 0 + paddingTop, childLeft + childWidth, paddingTop + ());
    childLeft += childWidth;
   }
  }
 }
}