public void setContentView(@LayoutRes int layoutResID) {
    getWindow().setContentView(layoutResID);
    initWindowDecorActionBar();
} 

@Override
public void setContentView(int layoutResID) {
    if (mContentParent == null) {
         //在這里生成一個DecorView
        installDecor();
    } else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
        mContentParent.removeAllViews();
    }
    ...
}
private void installDecor() {
    mForceDecorInstall = false;
    //mDecor  為DecorView
    if (mDecor == null) {
        mDecor = generateDecor(-1);
        mDecor.setDescendantFocusability(ViewGroup.FOCUS_AFTER_DESCENDANTS);
        mDecor.setIsRootNamespace(true);
        if (!mInvalidatePanelMenuPosted && mInvalidatePanelMenuFeatures != 0) {
            mDecor.postOnAnimation(mInvalidatePanelMenuRunnable);
        }
    } else {
        mDecor.setWindow(this);
    }
    ...
 }
protected DecorView generateDecor(int featureId) {
   ...
   // 在這里直接 new 了一個DecorView
   return new DecorView(context, featureId, this, getAttributes());
} 

protected ViewGroup generateLayout(DecorView decor) {
    //做一些窗體樣式的判斷
       ...
     //給窗體進(jìn)行裝飾
    int layoutResource;
    int features = getLocalFeatures();
    // System.out.println("Features: 0x" + Integer.toHexString(features));
    //加載系統(tǒng)布局 判斷到底是加載那個布局
    if ((features & (1 << FEATURE_SWIPE_TO_DISMISS)) != 0) {
        layoutResource = R.layout.screen_swipe_dismiss;
        setCloseOnSwipeEnabled(true);
    }  
...
    mDecor.startChanging();
    //將加載到的基礎(chǔ)布局添加到mDecor中
    mDecor.onResourcesLoaded(mLayoutInflater, layoutResource);
    //通過系統(tǒng)的content的資源ID去進(jìn)行實例化這個控件
    ViewGroup contentParent = (ViewGroup)findViewById(ID_ANDROID_CONTENT);
    if (contentParent == null) {
        throw new RuntimeException("Window couldn't find content container view");
    }
} 

final void handleResumeActivity(IBinder token,
        boolean clearHide, boolean isForward, boolean reallyResume, int seq, String reason) {
      ...
      //在此處執(zhí)行Activity的onResume方法
    r = performResumeActivity(token, clearHide, reason);
    if (r != null) {
        final Activity a = r.activity;
        if (localLOGV) Slog.v(
            TAG, "Resume " + r + " started activity: " +
            a.mStartedActivity + ", hideForNow: " + r.hideForNow
            + ", finished: " + a.mFinished);
        final int forwardBit = isForward ?
                WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION : 0;
        boolean willBeVisible = !a.mStartedActivity;
        if (!willBeVisible) {
            try {
                willBeVisible = ActivityManagerNative.getDefault().willActivityBeVisible(
                        a.getActivityToken());
            } catch (RemoteException e) {
                throw e.rethrowFromSystemServer();
            }
        }
        if (r.window == null && !a.mFinished && willBeVisible) {
            //獲取window對象
            r.window = r.activity.getWindow();
            //獲取DecorView
            View decor = r.window.getDecorView();
            decor.setVisibility(View.INVISIBLE);
            //獲取WindowManager，在這里getWindowManager()實質(zhì)上獲取的是ViewManager的子類對象WindowManager
            ViewManager wm = a.getWindowManager();
            WindowManager.LayoutParams l = r.window.getAttributes();
            a.mDecor = decor;
            l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
            l.softInputMode |= forwardBit;
            if (r.mPreserveWindow) {
                a.mWindowAdded = true;
                r.mPreserveWindow = false;
                 //獲取ViewRootImpl對象
                ViewRootImpl impl = decor.getViewRootImpl();
                if (impl != null) {
                    impl.notifyChildRebuilt();
                }
            }
            if (a.mVisibleFromClient && !a.mWindowAdded) {
                a.mWindowAdded = true;
                //在這里WindowManager將DecorView添加到PhoneWindow中
                wm.addView(decor, l);
            }
        } 

private void performTraversals() {
    if (!mStopped || mReportNextDraw) {
        ...
        int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
        int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);
          ...
         // Ask host how big it wants to be
         //View繪制：開始測量 View的測量時遞歸逐層測量，由父布局與子布局共同確認(rèn)子View的測量模式，在子布局測量完畢時確認(rèn)副布局的寬高,
         //在此方法執(zhí)行完畢后才可獲取到View的寬高，否側(cè)獲取的寬高都為0
        performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
       }
    if (didLayout) {
    //開始擺放，該方法是ViewGroup中的方法，例如 LinerLayout...
        performLayout(lp, mWidth, mHeight);
    }
    if (!cancelDraw && !newSurface) {
        //開始繪制,執(zhí)行View的onDraw（）方法
        performDraw();
    }
} 

private void performMeasure(int childWidthMeasureSpec, int childHeightMeasureSpec) {
    Trace.traceBegin(Trace.TRACE_TAG_VIEW, "measure");
    try {
        mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);
    } finally {
        Trace.traceEnd(Trace.TRACE_TAG_VIEW);
    }
} 

 */
public static class MeasureSpec {
    //int類型占4個字節(jié)，其中高2位表示尺寸測量模式，低30位表示具體的寬高信息
    private static final int MODE_SHIFT = 30;
    private static final int MODE_MASK  = 0x3 << MODE_SHIFT;
    /** @hide */
    @IntDef({UNSPECIFIED, EXACTLY, AT_MOST})
    @Retention(RetentionPolicy.SOURCE)
    public @interface MeasureSpecMode {}
    //如下所示是MeasureSpec中的三種模式：UNSPECIFIED、EXACTLY、AT_MOST 
    //UNSPECIFIED：未指定模式，父容器不限制View的大小，一般用于系統(tǒng)內(nèi)部的測量
    public static final int UNSPECIFIED = 0 << MODE_SHIFT;
    //AT_MOST：最大模式，對應(yīng)于在xml文件中指定控件大小為wrap_content屬性，子View的最終大小是父View指定的大小值，并且子View的大小不能大于這個值
    public static final int EXACTLY     = 1 << MODE_SHIFT;
    //EXACTLY ：精確模式，對應(yīng)于在xml文件中指定控件為match_parent屬性或者是具體的數(shù)值，父容器測量出View所需的具體大小
    public static final int AT_MOST     = 2 << MODE_SHIFT;
    //獲取測量模式
    @MeasureSpecMode
    public static int getMode(int measureSpec) {
        //noinspection ResourceType
        return (measureSpec & MODE_MASK);
    }
   //獲取寬高信息
    public static int getSize(int measureSpec) {
        return (measureSpec & ~MODE_MASK);
    }
     ...
} 

 public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
        boolean optical = isLayoutModeOptical(this);
        if (optical != isLayoutModeOptical(mParent)) {
            Insets insets = getOpticalInsets();
            int oWidth  = insets.left + insets.right;
            int oHeight = insets.top  + insets.bottom;
            //根據(jù)原有寬高計算獲取不同模式下的具體寬高值
            widthMeasureSpec  = MeasureSpec.adjust(widthMeasureSpec,  optical ? -oWidth  : oWidth);
            heightMeasureSpec = MeasureSpec.adjust(heightMeasureSpec, optical ? -oHeight : oHeight);
        }
        ...
        if (forceLayout || needsLayout) {
            // first clears the measured dimension flag
            mPrivateFlags &= ~PFLAG_MEASURED_DIMENSION_SET;
            resolveRtlPropertiesIfNeeded();
            int cacheIndex = forceLayout ? -1 : mMeasureCache.indexOfKey(key);
            if (cacheIndex < 0 || sIgnoreMeasureCache) {
                // measure ourselves, this should set the measured dimension flag back
                //在該方法中子控件完成具體的測量
                onMeasure(widthMeasureSpec, heightMeasureSpec);
                ...
            } 
         ...
    } 

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    if (mOrientation == VERTICAL) {
        measureVertical(widthMeasureSpec, heightMeasureSpec);
    } else {
        measureHorizontal(widthMeasureSpec, heightMeasureSpec);
    }
} 

void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {
    //獲取子View的個數(shù)
    final int count = getVirtualChildCount();
        ...
    //循環(huán)獲取所有子View
    for (int i = 0; i < count; ++i) {
        //獲取子View
        final View child = getVirtualChildAt(i);
        //調(diào)用子View的measure方法
        child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
    }
    ....
} 

private void performLayout(WindowManager.LayoutParams lp, int desiredWindowWidth,
        int desiredWindowHeight) {
        final View host = mView;
          // 在此處調(diào)用mView的layout()擺放開始
        host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());
     } 

 /*  
 *@param l view 左邊緣相對于父布局左邊緣距離 
 *@param t view 上邊緣相對于父布局上邊緣位置 
 *@param r view 右邊緣相對于父布局左邊緣距離 
 *@param b view 下邊緣相對于父布局上邊緣距離 
 */  
public void layout(int l, int t, int r, int b) {
      ...
   //記錄 view 原始位置  
    int oldL = mLeft;
    int oldT = mTop;
    int oldB = mBottom;
    int oldR = mRight;
  //調(diào)用 setFrame 方法 設(shè)置新的 mLeft、mTop、mBottom、mRight 值，  
  //設(shè)置 View 本身四個頂點位置  
  //并返回 changed 用于判斷 view 布局是否改變  
    boolean changed = isLayoutModeOptical(mParent) ?
            setOpticalFrame(l, t, r, b) : setFrame(l, t, r, b);
 //第二步，如果 view 位置改變那么調(diào)用 onLayout 方法設(shè)置子 view 位置 
    if (changed || (mPrivateFlags & PFLAG_LAYOUT_REQUIRED) == PFLAG_LAYOUT_REQUIRED) {
        //開始調(diào)用 onLayout  在此處根據(jù)子View的寬高及相關(guān)規(guī)則進(jìn)行擺放
        onLayout(changed, l, t, r, b);
          ...
            }
        }
    }
} 

private void performDraw() {
        ...
          //調(diào)用draw方法
        draw(fullRedrawNeeded);
        ...
    }
private void draw(boolean fullRedrawNeeded) {
        ...
     //View的繪制流程調(diào)用的   drawSoftware（） 該方法
if (!drawSoftware(surface, mAttachInfo, xOffset, yOffset, scalingRequired, dirty)) {
    return;
}
private boolean drawSoftware(Surface surface, AttachInfo attachInfo, int xoff, int yoff,
        boolean scalingRequired, Rect dirty) {
    final Canvas canvas;
       ...
    //初始化畫布
    canvas = mSurface.lockCanvas(dirty);
    ...
    //開始調(diào)用ViewGroup 和  View的draw方法
    mView.draw(canvas);
    ...
}
public void draw(Canvas canvas) {
    drawBackground(canvas);
    //ViewGroup  默認(rèn)是不會調(diào)用OnDraw方法的
    if (!dirtyOpaque) onDraw(canvas);
    //這個方法主要是ViewGroup循環(huán)調(diào)用 drawChild()進(jìn)行對子View的繪制
    dispatchDraw(canvas); 
}
protected void onDraw(Canvas canvas) {
}