• setContentView详解

    一、简介

    setContentView我们在Activity中经常见到，它的作用就是把我们的布局文件放在Activity中显示，下面我们根据源码分析setContentView是如何做到的

    二、源码分析

    1.两种setContentView

    注意Activity的setContentView和AppCompatActivity的setContentView是有一些区别的，所以我们要分析两钟setContentView，下面先分析Activity的

    2.Activity的setContentView

    (1).从Activity的setContentView这个方法开始

    1.     public void setContentView(@LayoutRes int layoutResID) {
    2.         getWindow().setContentView(layoutResID);
    3.         initWindowDecorActionBar();
    4.     }

    可以看到第一句getWindow().setContentView(layoutResID)，这个getWindow是获取当前Activity的Window，在Android中Window的实现类是phoneWindow,所以我们要看phoneWindow的setContentView

    顺便提一下Activity的window的创建时机是在Activity的attach方法:

     (2).继续跟踪到phoneWindow的setContentView

    1.     public void setContentView(int layoutResID) {
    2.         // Note: FEATURE_CONTENT_TRANSITIONS may be set in the process of installing the window
    3.         // decor, when theme attributes and the like are crystalized. Do not check the feature
    4.         // before this happens.
    5.         if (mContentParent == null) {
    6.             installDecor(); //⭐这句关键流程
    7.         } else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
    8.             mContentParent.removeAllViews();
    9.         }
    10.  
    11.         if (hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
    12.             final Scene newScene = Scene.getSceneForLayout(mContentParent, layoutResID,
    13.                     getContext());
    14.             transitionTo(newScene);
    15.         } else {
    16.             mLayoutInflater.inflate(layoutResID, mContentParent);//⭐这句关键流程
    17.  
    18.         }
    19.         mContentParent.requestApplyInsets();
    20.         final Callback cb = getCallback();
    21.         if (cb != null && !isDestroyed()) {
    22.             cb.onContentChanged();
    23.         }
    24.         mContentParentExplicitlySet = true; //⭐这个flag记一下
    25.     }

    上面代码中我标记了三处重点，我们下面继续分析这三个重点都干了什么，先分析第一个installDecor()

    (2.1).分析phoneWindow的setContentView的第一个关键点installDecor()

     installDecor主要是我用红框标记出来的是重点，我们先分析generateDecor(-1)这个方法:

    (2.1.1).分析installDecor()方法中的generateDecor(-1)方法

    1.     protected DecorView generateDecor(int featureId) {
    2.         // System process doesn't have application context and in that case we need to directly use
    3.         // the context we have. Otherwise we want the application context, so we don't cling to the
    4.         // activity.
    5.         Context context;
    6.         if (mUseDecorContext) {
    7.             Context applicationContext = getContext().getApplicationContext();
    8.             if (applicationContext == null) {
    9.                 context = getContext();
    10.             } else {
    11.                 context = new DecorContext(applicationContext, this);
    12.                 if (mTheme != -1) {
    13.                     context.setTheme(mTheme);
    14.                 }
    15.             }
    16.         } else {
    17.             context = getContext();
    18.         }
    19.         return new DecorView(context, featureId, this, getAttributes());//⭐重点
    20.     }

    创建了一个DecorView并且返回之后赋值给了mDecor，我们先看一下这个DecorVIew是什么:

     很明显是一个FrameLayout，这下我们知道了创建了一个FrameLayout类型的DecorView然后赋值给了mDecor变量,下面继续分析installDecor的第二个重点：generateLayout(mDecor)

    (2.1.2).分析installDecor的第二个重点：generateLayout(mDecor)

    1.     protected ViewGroup generateLayout(DecorView decor) {
    2.     ...
    3. else {
    4.             // Embedded, so no decoration is needed.
    5.             layoutResource = R.layout.screen_simple; 
    6.             // System.out.println("Simple!");
    7.         }
    8.  
    9.         mDecor.startChanging();
    10.         mDecor.onResourcesLoaded(mLayoutInflater, layoutResource); //⭐重点下面的方法
    11.  
    12.         ViewGroup contentParent = (ViewGroup)findViewById(ID_ANDROID_CONTENT);
    13.         if (contentParent == null) {
    14.             throw new RuntimeException("Window couldn't find content container view");
    15.         }
    16.     ...
    17.         return contentParent;
    18.     }
    19.  
    20.     //⭐DecorView的onResourcesLoaded方法
    21.     void onResourcesLoaded(LayoutInflater inflater, int layoutResource) {
    22.         if (mBackdropFrameRenderer != null) {
    23.             loadBackgroundDrawablesIfNeeded();
    24.             mBackdropFrameRenderer.onResourcesLoaded(
    25.                     this, mResizingBackgroundDrawable, mCaptionBackgroundDrawable,
    26.                     mUserCaptionBackgroundDrawable, getCurrentColor(mStatusColorViewState),
    27.                     getCurrentColor(mNavigationColorViewState));
    28.         }
    29.  
    30.         mDecorCaptionView = createDecorCaptionView(inflater);
    31.         final View root = inflater.inflate(layoutResource, null);//⭐重点主线流程
    32.         if (mDecorCaptionView != null) {
    33.             if (mDecorCaptionView.getParent() == null) {
    34.                 addView(mDecorCaptionView,
    35.                         new ViewGroup.LayoutParams(MATCH_PARENT, MATCH_PARENT));
    36.             }
    37.             mDecorCaptionView.addView(root,
    38.                     new ViewGroup.MarginLayoutParams(MATCH_PARENT, MATCH_PARENT));
    39.         } else {
    40.  
    41.             // Put it below the color views. ⭐重点主线流程
    42.             addView(root, 0, new ViewGroup.LayoutParams(MATCH_PARENT, MATCH_PARENT));
    43.         }
    44.         mContentRoot = (ViewGroup) root;
    45.         initializeElevation();
    46.     }

    这个方法的作用就是，通过我们设置的style或者requestWindowFuture等来选出一个系统自带的布局文件，默认的是R.layout.screen_simple，选出布局文件后，通过调用mDecor.onResourcesLoaded(mLayoutInflater, layoutResource);方法inflate出来后，add到DecorView上，我们详细看一下R.layout.screen_simple这个布局文件:

    1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    2.     android:layout_width="match_parent"
    3.     android:layout_height="match_parent"
    4.     android:fitsSystemWindows="true"
    5.     android:orientation="vertical">
    6.     <ViewStub android:id="@+id/action_mode_bar_stub"
    7.               android:inflatedId="@+id/action_mode_bar"
    8.               android:layout="@layout/action_mode_bar"
    9.               android:layout_width="match_parent"
    10.               android:layout_height="wrap_content"
    11.               android:theme="?attr/actionBarTheme" />
    12.     <FrameLayout
    13.          android:id="@android:id/content"
    14.          android:layout_width="match_parent"
    15.          android:layout_height="match_parent"
    16.          android:foregroundInsidePadding="false"
    17.          android:foregroundGravity="fill_horizontal|top"
    18.          android:foreground="?android:attr/windowContentOverlay" />
    19. LinearLayout>

     就是这个布局文件，被inflate到DecorView上，然后通过

    ViewGroup contentParent = (ViewGroup)findViewById(ID_ANDROID_CONTENT);

    这一句获取到这个是content的FrameLayout，然后返回了这个contentParent

    到这里installDecor这个方法分析完了，总结一下，installDecor方法主要就是创建DecorView，然后把选出的布局文件add到DecorView上，然后再通过findViewbyId找到类型是FrameLayout的content赋值给contentParent 返回，其实还有一步是DecorView和phoneWindow结合，这里不细说，以后有FrameWorker源码解析再说。

     (2.2).继续分析phoneWindow的setContentView的第二个关键流程重点

     mLayoutInflater.inflate(layoutResID, mContentParent);

    这句很明显，layoutResID是我们的activity_main.layout这种自己写的布局文件，把它inflate到mContentParent中，通过图片让大家有一个更清晰的感官:

     (2.3).继续分析phoneWindow的setContentView的第三个关键流程重点

    mContentParentExplicitlySet = true;

    这个flag的作用首先我们先看一段代码:

    1. public class MainActivity extends AppCompatActivity {
    2.  
    3.     @Override
    4.     protected void onCreate(Bundle savedInstanceState) {
    5.         super.onCreate(savedInstanceState);
    6.         setContentView(R.layout.activity_main);
    7.         requestWindowFeature(Window.FEATURE_NO_TITLE);
    8.     }
    9. }

    这段代码运行会报错:

    requestFeature() must be called before adding content

     为什么会报这个错误呢，从代码上来找:

    1.     public final boolean requestWindowFeature(int featureId) {
    2.         return getWindow().requestFeature(featureId);
    3.     }
    4.  
    5.     //我们已经知道，getWindow其实获取的是PhoneWindow所以调用的是PhoneWindow的requestFeature
    6.     @Override
    7.     public boolean requestFeature(int featureId) {
    8.         if (mContentParentExplicitlySet) { //⭐这就是报错的根源
    9.             throw new AndroidRuntimeException("requestFeature() must be called before adding content"); 
    10.         }
    11.         final int features = getFeatures();
    12.         final int newFeatures = features | (1 << featureId);
    13.         if ((newFeatures & (1 << FEATURE_CUSTOM_TITLE)) != 0 &&
    14.                 (newFeatures & ~CUSTOM_TITLE_COMPATIBLE_FEATURES) != 0) {
    15.             // Another feature is enabled and the user is trying to enable the custom title feature
    16.             // or custom title feature is enabled and the user is trying to enable another feature
    17.             throw new AndroidRuntimeException(
    18.                     "You cannot combine custom titles with other title features");
    19.         }
    20.         if ((features & (1 << FEATURE_NO_TITLE)) != 0 && featureId == FEATURE_ACTION_BAR) {
    21.             return false; // Ignore. No title dominates.
    22.         }
    23.         if ((features & (1 << FEATURE_ACTION_BAR)) != 0 && featureId == FEATURE_NO_TITLE) {
    24.             // Remove the action bar feature if we have no title. No title dominates.
    25.             removeFeature(FEATURE_ACTION_BAR);
    26.         }
    27.  
    28.         if (featureId == FEATURE_INDETERMINATE_PROGRESS &&
    29.                 getContext().getPackageManager().hasSystemFeature(PackageManager.FEATURE_WATCH)) {
    30.             throw new AndroidRuntimeException("You cannot use indeterminate progress on a watch.");
    31.         }
    32.         return super.requestFeature(featureId);
    33.     }

    看到了报错的根源，其实就是mContentParentExplicitlySet这个flag，在setContentView执行完就设置成了true，所以调用requestWindowFeature(Window.FEATURE_NO_TITLE);方法必须在setContentView之前，否则就会抛出异常，最后从设计的角度分析，为什么要设计这么一个flag呢，或者说为什么非要在setContentView之前执行requestFeature，因为在setContentView中需要通过设置的这些requestWindowFeature的flag去选择一个布局文件然后add到DecorView上，如果在setContentView后面设置就起不到作用，所以有了这个设计。

    3.AppCompatActivity的setContentView

    (1).AppCompatActivity的setContentView源码

    1.     @Override
    2.     public void setContentView(@LayoutRes int layoutResID) {
    3.         getDelegate().setContentView(layoutResID);
    4.     }

    (1.1).getDelegate()

    1.     @NonNull
    2.     public AppCompatDelegate getDelegate() {
    3.         if (mDelegate == null) {
    4.             mDelegate = AppCompatDelegate.create(this, this);
    5.         }
    6.         return mDelegate;
    7.     }

    实际上实现类是AppCompatDelegate，getDelegate().setContentView(layoutResID);的setContentView实际上是AppCompatDelegate的setContentView方法

    (2).AppCompatDelegate的setContentView方法

    1.     @Override
    2.     public void setContentView(int resId) {
    3.         ensureSubDecor(); //⭐重点主线
    4.         ViewGroup contentParent = mSubDecor.findViewById(android.R.id.content); //⭐重点主线
    5.         contentParent.removeAllViews();
    6.         LayoutInflater.from(mContext).inflate(resId, contentParent);//⭐重点主线
    7.         mAppCompatWindowCallback.getWrapped().onContentChanged();
    8.     }

    (2.1).分析ensureSubDecor()方法

    1.     private void ensureSubDecor() {
    2.         if (!mSubDecorInstalled) {
    3.             mSubDecor = createSubDecor(); // ⭐重点主线流程
    4.  
    5.             // If a title was set before we installed the decor, propagate it now
    6.             CharSequence title = getTitle();
    7.             if (!TextUtils.isEmpty(title)) {
    8.                 if (mDecorContentParent != null) {
    9.                     mDecorContentParent.setWindowTitle(title);
    10.                 } else if (peekSupportActionBar() != null) {
    11.                     peekSupportActionBar().setWindowTitle(title);
    12.                 } else if (mTitleView != null) {
    13.                     mTitleView.setText(title);
    14.                 }
    15.             }
    16.  
    17.             applyFixedSizeWindow();
    18.  
    19.             onSubDecorInstalled(mSubDecor);
    20.  
    21.             mSubDecorInstalled = true;//⭐这个flag参数
    22.  
    23.             // Invalidate if the panel menu hasn't been created before this.
    24.             // Panel menu invalidation is deferred avoiding application onCreateOptionsMenu
    25.             // being called in the middle of onCreate or similar.
    26.             // A pending invalidation will typically be resolved before the posted message
    27.             // would run normally in order to satisfy instance state restoration.
    28.             PanelFeatureState st = getPanelState(FEATURE_OPTIONS_PANEL, false);
    29.             if (!mIsDestroyed && (st == null || st.menu == null)) {
    30.                 invalidatePanelMenu(FEATURE_SUPPORT_ACTION_BAR);
    31.             }
    32.         }
    33.     }

     主要的第一句:

    mSubDecor = createSubDecor();

    mSubDecor是一个ViewGroup类型的对象，下面我们分析createSubDecor()

    (2.1.1).ensureSubDecor()方法中的createSubDecor()方法

    1.     private ViewGroup createSubDecor() {
    2.         TypedArray a = mContext.obtainStyledAttributes(R.styleable.AppCompatTheme);
    3.         
    4.         //⭐这个错误是不是曾经见到过，如果用的Theme不是AppCompatTheme的就会报错
    5.         if (!a.hasValue(R.styleable.AppCompatTheme_windowActionBar)) {
    6.             a.recycle();
    7.             throw new IllegalStateException(
    8.                     "You need to use a Theme.AppCompat theme (or descendant) with this activity.");
    9.         }
    10. ......
    11.  
    12.         // Now let's make sure that the Window has installed its decor by retrieving it
    13.         ensureWindow(); 
    14.         mWindow.getDecorView();  
    15.  
    16.  
    17.         final LayoutInflater inflater = LayoutInflater.from(mContext);
    18.         ViewGroup subDecor = null;
    19.  
    20.  
    21.         if (!mWindowNoTitle) {
    22. ......
    23.         } else {
    24. ......
    25.            subDecor = (ViewGroup) inflater.inflate(R.layout.abc_screen_simple, null);
    26. ......
    27.         }
    28. ......
    29.  
    30.         final ContentFrameLayout contentView = (ContentFrameLayout) subDecor.findViewById(
    31.                 R.id.action_bar_activity_content);
    32.  
    33.         final ViewGroup windowContentView = (ViewGroup) mWindow.findViewById(android.R.id.content);
    34.         if (windowContentView != null) {
    35.             // There might be Views already added to the Window's content view so we need to
    36.             // migrate them to our content view
    37.             while (windowContentView.getChildCount() > 0) {
    38.                 final View child = windowContentView.getChildAt(0);
    39.                 windowContentView.removeViewAt(0);
    40.                 contentView.addView(child);
    41.             }
    42.  
    43.             // Change our content FrameLayout to use the android.R.id.content id.
    44.             // Useful for fragments.
    45.             windowContentView.setId(View.NO_ID);
    46.             contentView.setId(android.R.id.content);
    47.  
    48.             // The decorContent may have a foreground drawable set (windowContentOverlay).
    49.             // Remove this as we handle it ourselves
    50.             if (windowContentView instanceof FrameLayout) {
    51.                 ((FrameLayout) windowContentView).setForeground(null);
    52.             }
    53.         }
    54.  
    55.         // Now set the Window's content view with the decor
    56.         mWindow.setContentView(subDecor);
    57. ......
    58.  
    59.         return subDecor;
    60.     }

    上面显示出来的基本上都很重要，我们一句一句分析:

    (2.1.1.1).ensureWindow(); 

    1.     private void ensureWindow() {
    2.         // We lazily fetch the Window for Activities, to allow DayNight to apply in
    3.         // attachBaseContext
    4.         if (mWindow == null && mHost instanceof Activity) {
    5.             attachToWindow(((Activity) mHost).getWindow());
    6.         }
    7.         if (mWindow == null) {
    8.             throw new IllegalStateException("We have not been given a Window");
    9.         }
    10.     }

    首先我们要明确AppCompatActivity是继承自Activity的，所以window也是在attach方法中创建的，在AppCompatDelegateImpl中也维护了一个Window类型的变量是mWindow，就是通过这个ensureWindow方法经过检查后赋值过来的。说白了ensureWindow方法就是把AppCompatActivity中的Window对象赋值到AppCompatDelegateImpl对象中，当然对window设置的callBack啥的也换成AppCompatDelegateImpl中的。

    (2.1.1.2).mWindow.getDecorView()方法

    Window的实现类，所以我们要看PhoneWindow的getDecorView()方法:

    1.     @Override
    2.     public final @NonNull View getDecorView() {
    3.         if (mDecor == null || mForceDecorInstall) {
    4.             installDecor();
    5.         }
    6.         return mDecor;
    7.     }

    可以看到是调用了installDecor，和Activity有了相同的部分，我们简单回忆一下installDecor干了啥，首先创建了DecorView，然后通过解析我们style的设置选出合适的系统自带布局文件，把它add到DecorView上，并且返回了一个id是com.android.internal.R.id.content的FrameLayout（将来我们要把我们的activity_mai的layout文件add到这个content上面）。

    (2.1.1.3).后面要分析的这一堆代码就是Activity和AppCompatActivity的setContentView的主要区别

    1. ....
    2.  subDecor = (ViewGroup) inflater.inflate(R.layout.abc_screen_simple, null);
    3. ....
    4. final ContentFrameLayout contentView = (ContentFrameLayout) subDecor.findViewById(
    5.                 R.id.action_bar_activity_content);
    6.  
    7.         final ViewGroup windowContentView = (ViewGroup) mWindow.findViewById(android.R.id.content);
    8.         if (windowContentView != null) {
    9.             // There might be Views already added to the Window's content view so we need to
    10.             // migrate them to our content view
    11.             while (windowContentView.getChildCount() > 0) {
    12.                 final View child = windowContentView.getChildAt(0);
    13.                 windowContentView.removeViewAt(0);
    14.                 contentView.addView(child);
    15.             }
    16.  
    17.             // Change our content FrameLayout to use the android.R.id.content id.
    18.             // Useful for fragments.
    19.             windowContentView.setId(View.NO_ID);
    20.             contentView.setId(android.R.id.content);
    21.  
    22. ......
    23.         }
    24.  
    25.         // Now set the Window's content view with the decor
    26.         mWindow.setContentView(subDecor);
    27. ......
    28.  
    29.         return subDecor;
    30.     }

    通过我们设置的style选出一个布局文件，这一步好像在installDecor中已经做过了，这样好像重复了，为什么有这样的一个重复?有这样一个重复是为了不影响原来的代码的同时，把一部分对style处理的逻辑转移到AppCompatDelegateImpl中，例如对windowTitle的隐藏与显示，这里可看出来设计师的设计，通过下面的学习慢慢体会，先看一下这个布局文件：

    1. <androidx.appcompat.widget.FitWindowsLinearLayout
    2.     xmlns:android="http://schemas.android.com/apk/res/android"
    3.     android:id="@+id/action_bar_root"
    4.     android:layout_width="match_parent"
    5.     android:layout_height="match_parent"
    6.     android:orientation="vertical"
    7.     android:fitsSystemWindows="true">
    8.  
    9.     <androidx.appcompat.widget.ViewStubCompat
    10.         android:id="@+id/action_mode_bar_stub"
    11.         android:inflatedId="@+id/action_mode_bar"
    12.         android:layout="@layout/abc_action_mode_bar"
    13.         android:layout_width="match_parent"
    14.         android:layout_height="wrap_content" />
    15.  
    16.     <include layout="@layout/abc_screen_content_include" />
    17.  
    18. androidx.appcompat.widget.FitWindowsLinearLayout>
    19.  
    20.  
    21. abc_screen_content_include的布局文件:
    22. <merge xmlns:android="http://schemas.android.com/apk/res/android">
    23.  
    24.     <androidx.appcompat.widget.ContentFrameLayout
    25.             android:id="@id/action_bar_activity_content"
    26.             android:layout_width="match_parent"
    27.             android:layout_height="match_parent"
    28.             android:foregroundGravity="fill_horizontal|top"
    29.             android:foreground="?android:attr/windowContentOverlay" />
    30.  
    31. merge>

    把这个布局文件inflate成view赋值给subDecor，subDecor是一个ViewGroup：

    下面重点来了:

    final ContentFrameLayout contentView = (ContentFrameLayout) subDecor.findViewById(
        R.id.action_bar_activity_content);

    这一句是获取subDecor中的id是 action_bar_activity_content的ContentFrameLayout类型的View赋值给contentView

    final ViewGroup windowContentView = (ViewGroup) mWindow.findViewById(android.R.id.content);

     windowContentView是获取installDecor中选择的那个布局的id是android.R.id.content的那个FrameLayout

    while (windowContentView.getChildCount() > 0) {
    final View child = windowContentView.getChildAt(0);
    windowContentView.removeViewAt(0);
    contentView.addView(child);
}

    如果windowContentView中有子View，那就全部转移到contentView上

    windowContentView.setId(View.NO_ID);
contentView.setId(android.R.id.content);

     然后把windowContentView的id设置成NO_ID，把contentView的id设置成android.R.id.content，这就是想把AppCompatDelegateImple中选的这个系统自带布局文件的content替换掉之前的installDecor方法中布局文件的content，以后我们的activity_main的layout布局文件就加载在替换之后的content上

    mWindow.setContentView(subDecor);

    这句调用的是phoneWindow的setContentView方法

    1.     @Override
    2.     public void setContentView(View view) {
    3.         setContentView(view, new ViewGroup.LayoutParams(MATCH_PARENT, MATCH_PARENT));
    4.     }
    5.  
    6.     @Override
    7.     public void setContentView(View view, ViewGroup.LayoutParams params) {
    8.         // Note: FEATURE_CONTENT_TRANSITIONS may be set in the process of installing the window
    9.         // decor, when theme attributes and the like are crystalized. Do not check the feature
    10.         // before this happens.
    11.         if (mContentParent == null) {
    12.             installDecor();
    13.         } else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
    14.             mContentParent.removeAllViews();
    15.         }
    16.  
    17.         if (hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
    18.             view.setLayoutParams(params);
    19.             final Scene newScene = new Scene(mContentParent, view);
    20.             transitionTo(newScene);
    21.         } else {
    22.             mContentParent.addView(view, params); //⭐把contentView添加到mContentParent上
    23.         }
    24.         mContentParent.requestApplyInsets();
    25.         final Callback cb = getCallback();
    26.         if (cb != null && !isDestroyed()) {
    27.             cb.onContentChanged();
    28.         }
    29.         mContentParentExplicitlySet = true;
    30.     }

    我们看一下mContentParent是什么：

    mContentParent = generateLayout(mDecor);

    是我们取消ID的那个之前的content，也就是说把AppCompatDelegateImpl的选择的系统自带布局文件(subDecor)，添加到之前的content中，最后返回subDecor注意这个subDecor是系统自带布局inflate出来的，接下来我们通过一张图加深理解：

     (2.1.2).ensureSubDecor()方法中的一个boolean值mSubDecorInstalled

    这个mSubDecorInstalled和Activity中的mContentParentExplicitlySet一样，作用也是防止在setContentView之后调用

    supportRequestWindowFeature(Window.FEATURE_NO_TITLE);

    ，我们发现和Activity的不一样了，我们思考一下，为什么调用supportRequestWindowFeature而不是调用requestWindowFeature？

    Activity中处理这些style是在PhoneWIndow的installDecor中，而AppCompatActivity在处理一些style时是在AppCompatDelegateImpl中，requestWindowFeature是影响的installDecor，supportRequestWindowFeature是影响的AppCompatDelegateImpl，拿window的Title来举例，看上面放过的两张图，Activity的title是要在installDecor方法中决定的显示与隐藏的，而AppCompatActivity的title是放在AppCompatDelegateImpl中决定显示与隐藏的，我们用AppCompatActivity肯定是要在AppCompatDelegateImpl进行一些操作，而不是对installDecor中进行操作。

     下面看一下supportRequestWindowFeature调用逻辑:

    1.     public boolean supportRequestWindowFeature(int featureId) {
    2.         return getDelegate().requestWindowFeature(featureId);
    3.     }
    4.  
    5.     @Override
    6.     public boolean requestWindowFeature(int featureId) {
    7.         featureId = sanitizeWindowFeatureId(featureId);
    8.  
    9.         if (mWindowNoTitle && featureId == FEATURE_SUPPORT_ACTION_BAR) {
    10.             return false; // Ignore. No title dominates.
    11.         }
    12.         if (mHasActionBar && featureId == Window.FEATURE_NO_TITLE) {
    13.             // Remove the action bar feature if we have no title. No title dominates.
    14.             mHasActionBar = false;
    15.         }
    16.  
    17.         switch (featureId) {
    18.             case FEATURE_SUPPORT_ACTION_BAR:
    19.                 throwFeatureRequestIfSubDecorInstalled();
    20.                 mHasActionBar = true;
    21.                 return true;
    22.             case FEATURE_SUPPORT_ACTION_BAR_OVERLAY:
    23.                 throwFeatureRequestIfSubDecorInstalled();
    24.                 mOverlayActionBar = true;
    25.                 return true;
    26.             case FEATURE_ACTION_MODE_OVERLAY:
    27.                 throwFeatureRequestIfSubDecorInstalled();
    28.                 mOverlayActionMode = true;
    29.                 return true;
    30.             case Window.FEATURE_PROGRESS:
    31.                 throwFeatureRequestIfSubDecorInstalled();
    32.                 mFeatureProgress = true;
    33.                 return true;
    34.             case Window.FEATURE_INDETERMINATE_PROGRESS:
    35.                 throwFeatureRequestIfSubDecorInstalled();
    36.                 mFeatureIndeterminateProgress = true;
    37.                 return true;
    38.             case Window.FEATURE_NO_TITLE:
    39.                 throwFeatureRequestIfSubDecorInstalled();
    40.                 mWindowNoTitle = true;
    41.                 return true;
    42.         }
    43.  
    44.         return mWindow.requestFeature(featureId);
    45.     }
    46.  
    47.     //⭐mSubDecorInstalled 这参数眼熟吧
    48.     private void throwFeatureRequestIfSubDecorInstalled() {
    49.         if (mSubDecorInstalled) {
    50.             throw new AndroidRuntimeException(
    51.                     "Window feature must be requested before adding content");
    52.         }
    53.     }

    (2.2).AppCompatDelegateImpl中的setContentView(View v)剩下的一起说

    1. ViewGroup contentParent = mSubDecor.findViewById(android.R.id.content); //⭐重点主线
    2. contentParent.removeAllViews();
    3. LayoutInflater.from(mContext).inflate(resId, contentParent);//⭐重点主线

    获取contentview，注意这个contentView和Activity的contentView的区别，看上面那张图，把所有的view清除掉，然后把我们的activity_main的layout这种我们自己的布局加载上去

    3.分析LayoutInflater.from(mContext).inflate(resId, contentParent);方法

    (1).很经典的一道面试题，inflate三个参数都有什么作用

    或者说这三种写法有什么区别：

     我们先看源码，看完之后总结:

    1.     public View inflate(@LayoutRes int resource, @Nullable ViewGroup root, boolean attachToRoot) {
    2.         final Resources res = getContext().getResources();
    3.         if (DEBUG) {
    4.             Log.d(TAG, "INFLATING from resource: \"" + res.getResourceName(resource) + "\" ("
    5.                   + Integer.toHexString(resource) + ")");
    6.         }
    7.  
    8.         View view = tryInflatePrecompiled(resource, res, root, attachToRoot);
    9.         if (view != null) {
    10.             return view;
    11.         }
    12.         XmlResourceParser parser = res.getLayout(resource); //⭐把布局文件用xml解析器解析 
    13.         try {
    14.             return inflate(parser, root, attachToRoot); //调用inflate重载的方法
    15.         } finally {
    16.             parser.close();
    17.         }
    18.     }

    继续往下看inflate的重载方法，这个方法中就有这道面试题的答案:

    1.     public View inflate(XmlPullParser parser, @Nullable ViewGroup root, boolean attachToRoot) {
    2.         synchronized (mConstructorArgs) {
    3.             Trace.traceBegin(Trace.TRACE_TAG_VIEW, "inflate");
    4.  
    5.             final Context inflaterContext = mContext;
    6.             final AttributeSet attrs = Xml.asAttributeSet(parser);
    7.             Context lastContext = (Context) mConstructorArgs[0];
    8.             mConstructorArgs[0] = inflaterContext;
    9.             View result = root; //⭐重点
    10.  
    11.             try {
    12.                 advanceToRootNode(parser); //⭐确保下面的代码是首先解析的根布局标签
    13.                 final String name = parser.getName();
    14.  
    15.                 if (DEBUG) {
    16.                     System.out.println("**************************");
    17.                     System.out.println("Creating root view: "
    18.                             + name);
    19.                     System.out.println("**************************");
    20.                 }
    21.  
    22.                 if (TAG_MERGE.equals(name)) {
    23.                     if (root == null || !attachToRoot) {
    24.                         throw new InflateException(" can be used only with a valid "
    25.                                 + "ViewGroup root and attachToRoot=true");
    26.                     }
    27.  
    28.                     rInflate(parser, root, inflaterContext, attrs, false);
    29.                 } else { //⭐重点 else单独分析
    30.                     // Temp is the root view that was found in the xml
    31.                     final View temp = createViewFromTag(root, name, inflaterContext, attrs); 
    32.  
    33.                     ViewGroup.LayoutParams params = null;
    34.  
    35.                     if (root != null) {
    36.                         if (DEBUG) {
    37.                             System.out.println("Creating params from root: " +
    38.                                     root);
    39.                         }
    40.                         // Create layout params that match root, if supplied
    41.                         params = root.generateLayoutParams(attrs);
    42.                         if (!attachToRoot) {
    43.                             // Set the layout params for temp if we are not
    44.                             // attaching. (If we are, we use addView, below)
    45.                             temp.setLayoutParams(params);
    46.                         }
    47.                     }
    48.  
    49.                     if (DEBUG) {
    50.                         System.out.println("-----> start inflating children");
    51.                     }
    52.  
    53.                     // Inflate all children under temp against its context.
    54.                     rInflateChildren(parser, temp, attrs, true);
    55.  
    56.                     if (DEBUG) {
    57.                         System.out.println("-----> done inflating children");
    58.                     }
    59.  
    60.                     // We are supposed to attach all the views we found (int temp)
    61.                     // to root. Do that now.
    62.                     if (root != null && attachToRoot) {
    63.                         root.addView(temp, params);
    64.                     }
    65.  
    66.                     // Decide whether to return the root that was passed in or the
    67.                     // top view found in xml.
    68.                     if (root == null || !attachToRoot) {
    69.                         result = temp;
    70.                     }
    71.                 }
    72.  
    73.             } catch (XmlPullParserException e) {
    74.                 final InflateException ie = new InflateException(e.getMessage(), e);
    75.                 ie.setStackTrace(EMPTY_STACK_TRACE);
    76.                 throw ie;
    77.             } catch (Exception e) {
    78.                 final InflateException ie = new InflateException(
    79.                         getParserStateDescription(inflaterContext, attrs)
    80.                         + ": " + e.getMessage(), e);
    81.                 ie.setStackTrace(EMPTY_STACK_TRACE);
    82.                 throw ie;
    83.             } finally {
    84.                 // Don't retain static reference on context.
    85.                 mConstructorArgs[0] = lastContext;
    86.                 mConstructorArgs[1] = null;
    87.  
    88.                 Trace.traceEnd(Trace.TRACE_TAG_VIEW);
    89.             }
    90.  
    91.             return result;
    92.         }
    93.     }

    上面的代码太多我把关于这道题的主要代码逻辑拿出来:

    (1.1).advanceToRootNode(）这个方法就是确保第一个解析的是布局的根标签

    1.     private void advanceToRootNode(XmlPullParser parser)
    2.         throws InflateException, IOException, XmlPullParserException {
    3.         // Look for the root node.
    4.         int type;
    5.         while ((type = parser.next()) != XmlPullParser.START_TAG &&
    6.             type != XmlPullParser.END_DOCUMENT) {
    7.             // Empty
    8.         }
    9.  
    10.         if (type != XmlPullParser.START_TAG) {
    11.             throw new InflateException(parser.getPositionDescription()
    12.                 + ": No start tag found!");
    13.         }
    14.     }

    (1.2).else的逻辑单独分析

    1. else {
    2.                     // Temp is the root view that was found in the xml
    3.                     final View temp = createViewFromTag(root, name, inflaterContext, attrs);
    4.  
    5.                     ViewGroup.LayoutParams params = null;
    6.  
    7.                     if (root != null) {
    8.                         if (DEBUG) {
    9.                             System.out.println("Creating params from root: " +
    10.                                     root);
    11.                         }
    12.                         // Create layout params that match root, if supplied
    13.                         params = root.generateLayoutParams(attrs);
    14.                         if (!attachToRoot) {
    15.                             // Set the layout params for temp if we are not
    16.                             // attaching. (If we are, we use addView, below)
    17.                             temp.setLayoutParams(params);
    18.                         }
    19.                     }
    20.  
    21.                     if (DEBUG) {
    22.                         System.out.println("-----> start inflating children");
    23.                     }
    24.  
    25.                     // Inflate all children under temp against its context.
    26.                     rInflateChildren(parser, temp, attrs, true);
    27.  
    28.                     if (DEBUG) {
    29.                         System.out.println("-----> done inflating children");
    30.                     }
    31.  
    32.                     // We are supposed to attach all the views we found (int temp)
    33.                     // to root. Do that now.
    34.                     if (root != null && attachToRoot) {
    35.                         root.addView(temp, params);
    36.                     }
    37.  
    38.                     // Decide whether to return the root that was passed in or the
    39.                     // top view found in xml.
    40.                     if (root == null || !attachToRoot) {
    41.                         result = temp;
    42.                     }
    43.                 }

    下面逐句分析：

    (1.2.1)

    final View temp = createViewFromTag(root, name, inflaterContext, attrs);

    这一句就是通过name，来反射创建view，下面会详细分析如何创建的view，这个temp就是布局文件的根view

    (1.2.2)

    if (root != null) {
    if (DEBUG) {
        System.out.println("Creating params from root: " +
                root);
    }
    // Create layout params that match root, if supplied
    params = root.generateLayoutParams(attrs);
    if (!attachToRoot) {
        // Set the layout params for temp if we are not
        // attaching. (If we are, we use addView, below)
        temp.setLayoutParams(params);
    }
}

    这就是如果inflate方法的第二个参数root不是null，那就执行这段代码：

    params = root.generateLayoutParams(attrs);

    这段代码的意思是：我们把新视图的根布局参数传递给root。让root进行转换成适合它自身布局的布局参数（因为不同的布局有不同的特性，例如LinearLayout和FrameLayout，我们要把布局文件的根temp这个View放到root中，就要让temp原来的布局参数转换成适合root这个ViewGroup布局的参数），如果inflate第三个参数attachToRoot是false就把布局文件的根view设置成转换的params

    (1.2.3)

    rInflateChildren(parser, temp, attrs, true);

    之后就继续解析布局文件，通过反射创建View，具体如何解析和创建之后详细分析

    (1.2.4)

    if (root != null && attachToRoot) {
    root.addView(temp, params);
}

    如果root不是null并且attachToRoot是true，把布局文件根生成的temp这个view添加到root上面，注意这个params还是上面转换的那个。

    (1.2.5)

    if (root == null || !attachToRoot) {
    result = temp;
}

    如果root是null或者attachToRoot是false，方法最后的返回值就是这个布局文件生成的View

    (1.2.6)

    到这里我们就知道了：

    1.当root不为null时，attachTORoot是true的时候就直接把我们布局生成的View添加到root(这个root是inflate方法参数的第二个参数)上面，并且方法最后的返回结果是root，如果attachTORoot是false，直接返回我们布局文件生成的View注意这个生成View的layoutParams已经set了，所以可以说：

    LayoutInflater.from(this).inflate(R.layout.activity_main,root,true);

    等价于

    View view = LayoutInflater.from(this).inflate(R.layout.activity_main,root,false);
root.addView(view);

    2.当root为null时，直接返回我们布局文件生成的view，注意这个生成的View没有layoutParams

    ,而且一旦root为null，后面的attachToRoot这个参数就失效了。

    (2).分析inflate方法如何解析和创建View的

     (2.1).在inflate布局文件的根标签时要注意merge标签

    if (TAG_MERGE.equals(name)) {
    if (root == null || !attachToRoot) {
        throw new InflateException(" can be used only with a valid "
                + "ViewGroup root and attachToRoot=true");
    }

    rInflate(parser, root, inflaterContext, attrs, false);
}

    当一个布局文件的根标签是merge时，如果root是null或者attachToRoot是false就报错，说明布局文件跟标签是merge时不能直接生成一个View，必须依附于其他View上。

    (2.2).解析不是根标签的布局

    1.     void rInflate(XmlPullParser parser, View parent, Context context,
    2.             AttributeSet attrs, boolean finishInflate) throws XmlPullParserException, IOException {
    3.  
    4.         final int depth = parser.getDepth();
    5.         int type;
    6.         boolean pendingRequestFocus = false;
    7.  
    8.         while (((type = parser.next()) != XmlPullParser.END_TAG ||
    9.                 parser.getDepth() > depth) && type != XmlPullParser.END_DOCUMENT) {
    10.  
    11.             if (type != XmlPullParser.START_TAG) {
    12.                 continue;
    13.             }
    14.  
    15.             final String name = parser.getName();
    16.  
    17.             if (TAG_REQUEST_FOCUS.equals(name)) {
    18.                 pendingRequestFocus = true;
    19.                 consumeChildElements(parser);
    20.             } else if (TAG_TAG.equals(name)) {
    21.                 parseViewTag(parser, parent, attrs);
    22.             } else if (TAG_INCLUDE.equals(name)) {
    23.                 if (parser.getDepth() == 0) {
    24.                     throw new InflateException(" cannot be the root element");
    25.                 }
    26.                 parseInclude(parser, context, parent, attrs);
    27.             } else if (TAG_MERGE.equals(name)) {
    28.                 throw new InflateException(" must be the root element");
    29.             } else {
    30.                 final View view = createViewFromTag(parent, name, context, attrs);
    31.                 final ViewGroup viewGroup = (ViewGroup) parent;
    32.                 final ViewGroup.LayoutParams params = viewGroup.generateLayoutParams(attrs);
    33.                 rInflateChildren(parser, view, attrs, true);
    34.                 viewGroup.addView(view, params);
    35.             }
    36.         }
    37.  
    38.         if (pendingRequestFocus) {
    39.             parent.restoreDefaultFocus();
    40.         }
    41.  
    42.         if (finishInflate) {
    43.             parent.onFinishInflate();
    44.         }
    45.     }

    (2.2.1).解析不是根布局时，注意对merge、include标签的处理

    对merge标签时直接报错，因为merge标签只能用于根标签，对include标签的处理，判断如果include是跟标签则报错，因为include标签不能用作根标签。

    (2.2.2).其他的view标签会走创建view，然后通过父布局生成对应的布局参数LayoutParams，然后添加在副布局上

    else {
    final View view = createViewFromTag(parent, name, context, attrs);
    final ViewGroup viewGroup = (ViewGroup) parent;
    final ViewGroup.LayoutParams params = viewGroup.generateLayoutParams(attrs);
    rInflateChildren(parser, view, attrs, true);
    viewGroup.addView(view, params);
}

    这一段中，createViewFromTag这个方法最重要，后面都是生成LayoutParams和添加到父布局上的逻辑，最后我们分析createViewFromTag这个方法

    (2.2.3).createViewFromTag创建view,注意这个Activity和AppCompatActivity有差别

    a.先分析Activity的createViewFromTag创建view的流程

    1.     private View createViewFromTag(View parent, String name, Context context, AttributeSet attrs) {
    2.         return createViewFromTag(parent, name, context, attrs, false);
    3.     }
    4.  
    5.     @UnsupportedAppUsage
    6.     View createViewFromTag(View parent, String name, Context context, AttributeSet attrs,
    7.             boolean ignoreThemeAttr) {
    8.         if (name.equals("view")) {
    9.             name = attrs.getAttributeValue(null, "class");
    10.         }
    11.  
    12.         // Apply a theme wrapper, if allowed and one is specified.
    13.         if (!ignoreThemeAttr) {
    14.             final TypedArray ta = context.obtainStyledAttributes(attrs, ATTRS_THEME);
    15.             final int themeResId = ta.getResourceId(0, 0);
    16.             if (themeResId != 0) {
    17.                 context = new ContextThemeWrapper(context, themeResId);
    18.             }
    19.             ta.recycle();
    20.         }
    21.  
    22.         try {
    23.             View view = tryCreateView(parent, name, context, attrs);
    24.  
    25.             if (view == null) {
    26.                 final Object lastContext = mConstructorArgs[0];
    27.                 mConstructorArgs[0] = context;
    28.                 try {
    29.                     if (-1 == name.indexOf('.')) { //⭐重点
    30.                         view = onCreateView(context, parent, name, attrs); //⭐重点
    31.                     } else {
    32.                         view = createView(context, name, null, attrs); //⭐重点
    33.                     }
    34.                 } finally {
    35.                     mConstructorArgs[0] = lastContext;
    36.                 }
    37.             }
    38.  
    39.             return view;
    40.         } catch (InflateException e) {
    41.             throw e;
    42.  
    43.         } catch (ClassNotFoundException e) {
    44.             final InflateException ie = new InflateException(
    45.                     getParserStateDescription(context, attrs)
    46.                     + ": Error inflating class " + name, e);
    47.             ie.setStackTrace(EMPTY_STACK_TRACE);
    48.             throw ie;
    49.  
    50.         } catch (Exception e) {
    51.             final InflateException ie = new InflateException(
    52.                     getParserStateDescription(context, attrs)
    53.                     + ": Error inflating class " + name, e);
    54.             ie.setStackTrace(EMPTY_STACK_TRACE);
    55.             throw ie;
    56.         }
    57.     }

     我们分析重点:

    if (view == null) {
    final Object lastContext = mConstructorArgs[0];
    mConstructorArgs[0] = context;
    try {
        if (-1 == name.indexOf('.')) {
            view = onCreateView(context, parent, name, attrs);
        } else {
            view = createView(context, name, null, attrs);
        }
    } finally {
        mConstructorArgs[0] = lastContext;
    }
}

return view;

    if (-1 == name.indexOf('.'))这个判断是标签是不是自定义View，带"."的是自定义View，如果不是自定义View，通过onCreateView创建View，如果是自定义View，通过createView创建View

    所以我们比较一下为啥不是自定义View要通过onCreateView创建而是自定义VIew的用createView创建

    先说一个知识点，LayoutInflater的实现类是PhoneLayoutInflater，onCreateView方法也被重写了:

    1.     private static final String[] sClassPrefixList = {
    2.         "android.widget.",
    3.         "android.webkit.",
    4.         "android.app."
    5.     };   
    6.  
    7.  @Override protected View onCreateView(String name, AttributeSet attrs) throws ClassNotFoundException {
    8.         for (String prefix : sClassPrefixList) {
    9.             try {
    10.                 View view = createView(name, prefix, attrs);
    11.                 if (view != null) {
    12.                     return view;
    13.                 }
    14.             } catch (ClassNotFoundException e) {
    15.                 // In this case we want to let the base class take a crack
    16.                 // at it.
    17.             }
    18.         }
    19.  
    20.         return super.onCreateView(name, attrs);
    21.     }
    22.  
    23. 最后还调用了super:
    24.     protected View onCreateView(String name, AttributeSet attrs)
    25.             throws ClassNotFoundException {
    26.         return createView(name, "android.view.", attrs);
    27.     }

    可以看到onCreateView最后还是调用了createVIew，所以onCreateView和createView主要的差别就是这个prefix的前缀，不是自定义View需要有前缀，想想LinearLayout这个类的全类名是"android.widget.LinearLayout"，这下知道了这些SDK自带的不是自定义View标签都会在这里补全全类名，最后看一下createView

    (2.2.4).createView方法

    1.  static final Class[] mConstructorSignature = new Class[] {
    2.             Context.class, AttributeSet.class}; //View的两个参数
    3.    
    4.  public final View createView(@NonNull Context viewContext, @NonNull String name,
    5.             @Nullable String prefix, @Nullable AttributeSet attrs)
    6.             throws ClassNotFoundException, InflateException {
    7.         Objects.requireNonNull(viewContext);
    8.         Objects.requireNonNull(name);
    9.         Constructorextends View> constructor = sConstructorMap.get(name);
    10.         if (constructor != null && !verifyClassLoader(constructor)) {
    11.             constructor = null;
    12.             sConstructorMap.remove(name);
    13.         }
    14.         Classextends View> clazz = null;
    15.  
    16.         try {
    17.             Trace.traceBegin(Trace.TRACE_TAG_VIEW, name);
    18.  
    19.             if (constructor == null) {//⭐主要就是通过反射去创建view
    20.                 // Class not found in the cache, see if it's real, and try to add it
    21.                 clazz = Class.forName(prefix != null ? (prefix + name) : name, false,
    22.                         mContext.getClassLoader()).asSubclass(View.class);
    23.  
    24.                 if (mFilter != null && clazz != null) {
    25.                     boolean allowed = mFilter.onLoadClass(clazz);
    26.                     if (!allowed) {
    27.                         failNotAllowed(name, prefix, viewContext, attrs);
    28.                     }
    29.                 }
    30.                 constructor = clazz.getConstructor(mConstructorSignature);//通过反射获取两个参数的构造方法，两个参数分别是context与AttributeSet（XML的参数集合）
    31.                 constructor.setAccessible(true);
    32.                 sConstructorMap.put(name, constructor); //用map缓存起来
    33.             } else { //constructor不为null说明map里面有直接用map里面的
    34.                 // If we have a filter, apply it to cached constructor
    35.                 if (mFilter != null) {
    36.                     // Have we seen this name before?
    37.                     Boolean allowedState = mFilterMap.get(name);
    38.                     if (allowedState == null) {
    39.                         // New class -- remember whether it is allowed
    40.                         clazz = Class.forName(prefix != null ? (prefix + name) : name, false,
    41.                                 mContext.getClassLoader()).asSubclass(View.class);
    42.  
    43.                         boolean allowed = clazz != null && mFilter.onLoadClass(clazz);
    44.                         mFilterMap.put(name, allowed);
    45.                         if (!allowed) {
    46.                             failNotAllowed(name, prefix, viewContext, attrs);
    47.                         }
    48.                     } else if (allowedState.equals(Boolean.FALSE)) {
    49.                         failNotAllowed(name, prefix, viewContext, attrs);
    50.                     }
    51.                 }
    52.             }
    53.  
    54.             Object lastContext = mConstructorArgs[0];
    55.             mConstructorArgs[0] = viewContext;
    56.             Object[] args = mConstructorArgs;
    57.             args[1] = attrs;
    58.  
    59.             try {
    60.                 final View view = constructor.newInstance(args);
    61.                 if (view instanceof ViewStub) {
    62.                     // Use the same context when inflating ViewStub later.
    63.                     final ViewStub viewStub = (ViewStub) view;
    64.                     viewStub.setLayoutInflater(cloneInContext((Context) args[0]));
    65.                 }
    66.                 return view;
    67.             } finally {
    68.                 mConstructorArgs[0] = lastContext;
    69.             }
    70.         } catch (NoSuchMethodException e) {
    71.             final InflateException ie = new InflateException(
    72.                     getParserStateDescription(viewContext, attrs)
    73.                     + ": Error inflating class " + (prefix != null ? (prefix + name) : name), e);
    74.             ie.setStackTrace(EMPTY_STACK_TRACE);
    75.             throw ie;
    76.  
    77.         } catch (ClassCastException e) {
    78.             // If loaded class is not a View subclass
    79.             final InflateException ie = new InflateException(
    80.                     getParserStateDescription(viewContext, attrs)
    81.                     + ": Class is not a View " + (prefix != null ? (prefix + name) : name), e);
    82.             ie.setStackTrace(EMPTY_STACK_TRACE);
    83.             throw ie;
    84.         } catch (ClassNotFoundException e) {
    85.             // If loadClass fails, we should propagate the exception.
    86.             throw e;
    87.         } catch (Exception e) {
    88.             final InflateException ie = new InflateException(
    89.                     getParserStateDescription(viewContext, attrs) + ": Error inflating class "
    90.                             + (clazz == null ? "" : clazz.getName()), e);
    91.             ie.setStackTrace(EMPTY_STACK_TRACE);
    92.             throw ie;
    93.         } finally {
    94.             Trace.traceEnd(Trace.TRACE_TAG_VIEW);
    95.         }
    96.     }

    这么一大堆代码其实就是通过反射去创建View，注意里面的注释

    b.再分析AppCompatActivity的createViewFromTag创建view的流程

    1.     private View createViewFromTag(View parent, String name, Context context, AttributeSet attrs) {
    2.         return createViewFromTag(parent, name, context, attrs, false);
    3.     }
    4.  
    5.     @UnsupportedAppUsage
    6.     View createViewFromTag(View parent, String name, Context context, AttributeSet attrs,
    7.             boolean ignoreThemeAttr) {
    8.         if (name.equals("view")) {
    9.             name = attrs.getAttributeValue(null, "class");
    10.         }
    11.  
    12.         // Apply a theme wrapper, if allowed and one is specified.
    13.         if (!ignoreThemeAttr) {
    14.             final TypedArray ta = context.obtainStyledAttributes(attrs, ATTRS_THEME);
    15.             final int themeResId = ta.getResourceId(0, 0);
    16.             if (themeResId != 0) {
    17.                 context = new ContextThemeWrapper(context, themeResId);
    18.             }
    19.             ta.recycle();
    20.         }
    21.  
    22.         try {
    23.             View view = tryCreateView(parent, name, context, attrs);//⭐重点
    24.  
    25.             if (view == null) {
    26.                 final Object lastContext = mConstructorArgs[0];
    27.                 mConstructorArgs[0] = context;
    28.                 try {
    29.                     if (-1 == name.indexOf('.')) { 
    30.                         view = onCreateView(context, parent, name, attrs);
    31.                     } else {
    32.                         view = createView(context, name, null, attrs); 
    33.                     }
    34.                 } finally {
    35.                     mConstructorArgs[0] = lastContext;
    36.                 }
    37.             }
    38.  
    39.             return view;
    40.         } catch (InflateException e) {
    41.             throw e;
    42.  
    43.         } catch (ClassNotFoundException e) {
    44.             final InflateException ie = new InflateException(
    45.                     getParserStateDescription(context, attrs)
    46.                     + ": Error inflating class " + name, e);
    47.             ie.setStackTrace(EMPTY_STACK_TRACE);
    48.             throw ie;
    49.  
    50.         } catch (Exception e) {
    51.             final InflateException ie = new InflateException(
    52.                     getParserStateDescription(context, attrs)
    53.                     + ": Error inflating class " + name, e);
    54.             ie.setStackTrace(EMPTY_STACK_TRACE);
    55.             throw ie;
    56.         }
    57.     }

     这个tryCreatView方法如果尝试创建View失败之后才轮到Activity的创建方式，我们看一下tryCreateView方法:

    1.     public final View tryCreateView(@Nullable View parent, @NonNull String name,
    2.         @NonNull Context context,
    3.         @NonNull AttributeSet attrs) {
    4.         if (name.equals(TAG_1995)) {
    5.             // Let's party like it's 1995!
    6.             return new BlinkLayout(context, attrs);
    7.         }
    8.  
    9.         View view;
    10.         if (mFactory2 != null) {
    11.             view = mFactory2.onCreateView(parent, name, context, attrs);
    12.         } else if (mFactory != null) {
    13.             view = mFactory.onCreateView(name, context, attrs);
    14.         } else {
    15.             view = null;
    16.         }
    17.  
    18.         if (view == null && mPrivateFactory != null) {
    19.             view = mPrivateFactory.onCreateView(parent, name, context, attrs);
    20.         }
    21.  
    22.         return view;
    23.     }

    发现有几个变量不认识，mFactory2和mFactory还有mPrivateFactory，我们的AppCompatActivity就是使用的mFactory2，看AppCompatActivity的onCreate方法:

    1.     @Override
    2.     protected void onCreate(@Nullable Bundle savedInstanceState) {
    3.         final AppCompatDelegate delegate = getDelegate();
    4.         delegate.installViewFactory(); // ⭐
    5.         delegate.onCreate(savedInstanceState);
    6.         super.onCreate(savedInstanceState);
    7.     }

    我们继续跟踪这个方法:

    1.     public void installViewFactory() {
    2.         LayoutInflater layoutInflater = LayoutInflater.from(mContext);
    3.         if (layoutInflater.getFactory() == null) {
    4.             LayoutInflaterCompat.setFactory2(layoutInflater, this);
    5.         } else {
    6.             if (!(layoutInflater.getFactory2() instanceof AppCompatDelegateImpl)) {
    7.                 Log.i(TAG, "The Activity's LayoutInflater already has a Factory installed"
    8.                         + " so we can not install AppCompat's");
    9.             }
    10.         }
    11.     }
    12.  
    13. //Factory2是一个接口
    14.     public interface Factory2 extends Factory {
    15.         @Nullable
    16.         View onCreateView(@Nullable View parent, @NonNull String name,
    17.                 @NonNull Context context, @NonNull AttributeSet attrs);
    18.     }
    19.  
    20. //LayoutInflater实现了这个接口
    21. class AppCompatDelegateImpl extends AppCompatDelegate
    22.         implements MenuBuilder.Callback, LayoutInflater.Factory2

    这下看到了，AppCompatActivity的oncreate方法中调用installViewFactory方法，获取到layoutInflater对象，AppCompatDelegateImpl实现了Factory2的接口，

    LayoutInflaterCompat.setFactory2(layoutInflater, this);
    1.    
    2.  public static void setFactory2(
    3.             @NonNull LayoutInflater inflater, @NonNull LayoutInflater.Factory2 factory) {
    4.         inflater.setFactory2(factory); // ⭐
    5.  
    6.         if (Build.VERSION.SDK_INT < 21) {
    7.             final LayoutInflater.Factory f = inflater.getFactory();
    8.             if (f instanceof LayoutInflater.Factory2) {
    9.                 // The merged factory is now set to getFactory(), but not getFactory2() (pre-v21).
    10.                 // We will now try and force set the merged factory to mFactory2
    11.                 forceSetFactory2(inflater, (LayoutInflater.Factory2) f);
    12.             } else {
    13.                 // Else, we will force set the original wrapped Factory2
    14.                 forceSetFactory2(inflater, factory);
    15.             }
    16.         }
    17.     }
    18.  
    19.  
    20. //LayoutInflater类中的方法
    21.     public void setFactory2(Factory2 factory) {
    22.         if (mFactorySet) {
    23.             throw new IllegalStateException("A factory has already been set on this LayoutInflater");
    24.         }
    25.         if (factory == null) {
    26.             throw new NullPointerException("Given factory can not be null");
    27.         }
    28.         mFactorySet = true;
    29.         if (mFactory == null) {
    30.             mFactory = mFactory2 = factory;
    31.         } else {
    32.             mFactory = mFactory2 = new FactoryMerger(factory, factory, mFactory, mFactory2);
    33.         }
    34.     }

    可以看到吧Factory2传进了infalter中，所以Inflater的对象中Factory2不是null了。

    Factory2不是null了，在执行创建createViewFromTag方法的tryCreateView时:

    1.     public final View tryCreateView(@Nullable View parent, @NonNull String name,
    2.         @NonNull Context context,
    3.         @NonNull AttributeSet attrs) {
    4.         if (name.equals(TAG_1995)) {
    5.             // Let's party like it's 1995!
    6.             return new BlinkLayout(context, attrs);
    7.         }
    8.  
    9.         View view;
    10.         if (mFactory2 != null) {
    11.             view = mFactory2.onCreateView(parent, name, context, attrs);
    12.         } else if (mFactory != null) {
    13.             view = mFactory.onCreateView(name, context, attrs);
    14.         } else {
    15.             view = null;
    16.         }
    17.  
    18.         if (view == null && mPrivateFactory != null) {
    19.             view = mPrivateFactory.onCreateView(parent, name, context, attrs);
    20.         }
    21.  
    22.         return view;
    23.     }

    mFactory2不是null了，就会执行 view = mFactory2.onCreateView(parent, name, context, attrs);

    我们知道，这个mFactory2其实就是AppCompatDelegateImpl的实例对象，这个设计挺巧妙和上面ensureDecor有点像，添加了一些逻辑，使对view的创建逻辑转移到了AppCompatDelegateImpl中，所以我们下面看AppCompatDelegateImpl的onCreateView方法:

    1.     @Override
    2.     public final View onCreateView(View parent, String name, Context context, AttributeSet attrs) {
    3.         return createView(parent, name, context, attrs);
    4.     }
    5.  
    6.     @Override
    7.     public View createView(View parent, final String name, @NonNull Context context,
    8.             @NonNull AttributeSet attrs) {
    9.         if (mAppCompatViewInflater == null) {
    10.             TypedArray a = mContext.obtainStyledAttributes(R.styleable.AppCompatTheme);
    11.             String viewInflaterClassName =
    12.                     a.getString(R.styleable.AppCompatTheme_viewInflaterClass);
    13.             if ((viewInflaterClassName == null)
    14.                     || AppCompatViewInflater.class.getName().equals(viewInflaterClassName)) {
    15.                 // Either default class name or set explicitly to null. In both cases
    16.                 // create the base inflater (no reflection)
    17.                 mAppCompatViewInflater = new AppCompatViewInflater();
    18.             } else {
    19.                 try {
    20.                     Class viewInflaterClass = Class.forName(viewInflaterClassName);
    21.                     mAppCompatViewInflater =
    22.                             (AppCompatViewInflater) viewInflaterClass.getDeclaredConstructor()
    23.                                     .newInstance();
    24.                 } catch (Throwable t) {
    25.                     Log.i(TAG, "Failed to instantiate custom view inflater "
    26.                             + viewInflaterClassName + ". Falling back to default.", t);
    27.                     mAppCompatViewInflater = new AppCompatViewInflater();
    28.                 }
    29.             }
    30.         }
    31.  
    32.         boolean inheritContext = false;
    33.         if (IS_PRE_LOLLIPOP) {
    34.             inheritContext = (attrs instanceof XmlPullParser)
    35.                     // If we have a XmlPullParser, we can detect where we are in the layout
    36.                     ? ((XmlPullParser) attrs).getDepth() > 1
    37.                     // Otherwise we have to use the old heuristic
    38.                     : shouldInheritContext((ViewParent) parent);
    39.         }
    40.         //⭐
    41.         return mAppCompatViewInflater.createView(parent, name, context, attrs, inheritContext,
    42.                 IS_PRE_LOLLIPOP, /* Only read android:theme pre-L (L+ handles this anyway) */
    43.                 true, /* Read read app:theme as a fallback at all times for legacy reasons */
    44.                 VectorEnabledTintResources.shouldBeUsed() /* Only tint wrap the context if enabled */
    45.         );
    46.     }

    可以看到创建了一个mAppCompatViewInflater ，最后调用了mAppCompatViewInflater的createView方法:

    1.     final View createView(View parent, final String name, @NonNull Context context,
    2.             @NonNull AttributeSet attrs, boolean inheritContext,
    3.             boolean readAndroidTheme, boolean readAppTheme, boolean wrapContext) {
    4.         final Context originalContext = context;
    5.  
    6.         // We can emulate Lollipop's android:theme attribute propagating down the view hierarchy
    7.         // by using the parent's context
    8.         if (inheritContext && parent != null) {
    9.             context = parent.getContext();
    10.         }
    11.         if (readAndroidTheme || readAppTheme) {
    12.             // We then apply the theme on the context, if specified
    13.             context = themifyContext(context, attrs, readAndroidTheme, readAppTheme);
    14.         }
    15.         if (wrapContext) {
    16.             context = TintContextWrapper.wrap(context);
    17.         }
    18.  
    19.         View view = null;
    20.  
    21.         // We need to 'inject' our tint aware Views in place of the standard framework versions
    22.         switch (name) {
    23.             case "TextView":
    24.                 view = createTextView(context, attrs);
    25.                 verifyNotNull(view, name);
    26.                 break;
    27.             case "ImageView":
    28.                 view = createImageView(context, attrs);
    29.                 verifyNotNull(view, name);
    30.                 break;
    31.             case "Button":
    32.                 view = createButton(context, attrs);
    33.                 verifyNotNull(view, name);
    34.                 break;
    35.             case "EditText":
    36.                 view = createEditText(context, attrs);
    37.                 verifyNotNull(view, name);
    38.                 break;
    39.             case "Spinner":
    40.                 view = createSpinner(context, attrs);
    41.                 verifyNotNull(view, name);
    42.                 break;
    43.             case "ImageButton":
    44.                 view = createImageButton(context, attrs);
    45.                 verifyNotNull(view, name);
    46.                 break;
    47.             case "CheckBox":
    48.                 view = createCheckBox(context, attrs);
    49.                 verifyNotNull(view, name);
    50.                 break;
    51.             case "RadioButton":
    52.                 view = createRadioButton(context, attrs);
    53.                 verifyNotNull(view, name);
    54.                 break;
    55.             case "CheckedTextView":
    56.                 view = createCheckedTextView(context, attrs);
    57.                 verifyNotNull(view, name);
    58.                 break;
    59.             case "AutoCompleteTextView":
    60.                 view = createAutoCompleteTextView(context, attrs);
    61.                 verifyNotNull(view, name);
    62.                 break;
    63.             case "MultiAutoCompleteTextView":
    64.                 view = createMultiAutoCompleteTextView(context, attrs);
    65.                 verifyNotNull(view, name);
    66.                 break;
    67.             case "RatingBar":
    68.                 view = createRatingBar(context, attrs);
    69.                 verifyNotNull(view, name);
    70.                 break;
    71.             case "SeekBar":
    72.                 view = createSeekBar(context, attrs);
    73.                 verifyNotNull(view, name);
    74.                 break;
    75.             case "ToggleButton":
    76.                 view = createToggleButton(context, attrs);
    77.                 verifyNotNull(view, name);
    78.                 break;
    79.             default:
    80.                 // The fallback that allows extending class to take over view inflation
    81.                 // for other tags. Note that we don't check that the result is not-null.
    82.                 // That allows the custom inflater path to fall back on the default one
    83.                 // later in this method.
    84.                 view = createView(context, name, attrs);
    85.         }
    86.  
    87.         if (view == null && originalContext != context) {
    88.             // If the original context does not equal our themed context, then we need to manually
    89.             // inflate it using the name so that android:theme takes effect.
    90.             view = createViewFromTag(context, name, attrs);
    91.         }
    92.  
    93.         if (view != null) {
    94.             // If we have created a view, check its android:onClick
    95.             checkOnClickListener(view, attrs);
    96.         }
    97.  
    98.         return view;
    99.     }

    可以看到有一个switch，如果View是case中的一种，那就把布局参数传进去重新创建一个AppCompat的View，如果不是case中的一种，进default，这个createView方法直接返回null，

    protected View createView(Context context, String name, AttributeSet attrs) {
    return null;
}

    然后走下面这句:

    if (view == null && originalContext != context) {
    // If the original context does not equal our themed context, then we need to manually
    // inflate it using the name so that android:theme takes effect.
    view = createViewFromTag(context, name, attrs);
}
    1.     private View createViewFromTag(Context context, String name, AttributeSet attrs) {
    2.         if (name.equals("view")) {
    3.             name = attrs.getAttributeValue(null, "class");
    4.         }
    5.  
    6.         try {
    7.             mConstructorArgs[0] = context;
    8.             mConstructorArgs[1] = attrs;
    9.  
    10.             if (-1 == name.indexOf('.')) {
    11.                 for (int i = 0; i < sClassPrefixList.length; i++) {
    12.                     final View view = createViewByPrefix(context, name, sClassPrefixList[i]);
    13.                     if (view != null) {
    14.                         return view;
    15.                     }
    16.                 }
    17.                 return null;
    18.             } else {
    19.                 return createViewByPrefix(context, name, null);
    20.             }
    21.         } catch (Exception e) {
    22.             // We do not want to catch these, lets return null and let the actual LayoutInflater
    23.             // try
    24.             return null;
    25.         } finally {
    26.             // Don't retain references on context.
    27.             mConstructorArgs[0] = null;
    28.             mConstructorArgs[1] = null;
    29.         }
    30.     }
    31.  
    32.     private View createViewByPrefix(Context context, String name, String prefix)
    33.             throws ClassNotFoundException, InflateException {
    34.         Constructorextends View> constructor = sConstructorMap.get(name);
    35.  
    36.         try {
    37.             if (constructor == null) {
    38.                 // Class not found in the cache, see if it's real, and try to add it
    39.                 Classextends View> clazz = Class.forName(
    40.                         prefix != null ? (prefix + name) : name,
    41.                         false,
    42.                         context.getClassLoader()).asSubclass(View.class);
    43.  
    44.                 constructor = clazz.getConstructor(sConstructorSignature);
    45.                 sConstructorMap.put(name, constructor);
    46.             }
    47.             constructor.setAccessible(true);
    48.             return constructor.newInstance(mConstructorArgs);
    49.         } catch (Exception e) {
    50.             // We do not want to catch these, lets return null and let the actual LayoutInflater
    51.             // try
    52.             return null;
    53.         }
    54.     }

    这个方法和Activity的逻辑一致了

    总结一下：AppCompatActivity通过LayoutInfater解析创建View时，会通过setFactory2拦截原有Activity的逻辑，去执行AppCompatDelegateImpl的逻辑，在View解析和创建的时候，会先检查，如果是AppCompat新设计的View就是case里的那一堆，就把这个View转换成AppCompat新设计的View，如果不是还是按照之前的逻辑来。

    三、总结

    1.setContentView的总结

    setContentView总的来说就是创建DecorView，DecorView是一个FrameLayout，然后根据style选择系统自带的布局文件，(例如有没有title，这里说一下这个布局文件根布局是linearLayout，如果有title则是有一个viewStub和两个FrameLayout：title的和content的，如果没有title则是一个viewstub和一个content的FrameLayout)，添加到DecorView上，最后再把我们自己的的activity_mian这种layout添加到content这个FrameLyout上。

    注意Activity和AppCompatActivity有一些区别，但总体上的逻辑是不变的。

     2.inflate的总结

    总结了inflate三个参数的作用，总结了解析到include、merge等标签时的注意点，总结了如何解析xml文件和如何创建View的重要流程。

  • 相关阅读:
    Mybatis源码的理解
    【机器学习】大模型环境下的应用：计算机视觉的探索与实践
    VBA 剪切板
    SSM+广西壮族文化宣传网站 毕业设计-附源码230932
    linux下keepalived的安装和配置
    gvim小记，包含了获取行号的函数【个人笔记，不喜勿喷】
    Redis主从复制
    分布式数据库Apache Doris HA集群部署
    一个反向代理神器 ——Nginx Proxy Manager
    40 - 前置操作符和后置操作符
  • 原文地址：https://blog.csdn.net/m0_37707561/article/details/125890487