devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android UI深度理解：Activity UI视图结构_android activity层级

作者：羊村懒王 | 2024-04-30 05:47:47

赞

踩

android activity层级

Activity UI视图结构

Android UI层级结构图
每个Activity都会获得一个窗口，那就是Window，它用于绘制用户的UI界面
Window是一个抽象类，提供了绘制窗口的一组通用API，PhoneWindow是它的唯一实现类
DecorView是所有应用窗口的根节点。是FrameLayout的子类
PhoneWindow内部实现xml布局文件的加载，容器为根据feature进行加载的对应的layout布局中android:id="@android:id/content"的ViewGroup类型的容器

在这里插入图片描述

 源码分析

xml布局文件的使用

  1. public class MainActivity extends Activity {
  2.     @Override
  3.     protected void onCreate(@Nullable Bundle savedInstanceState) {
  4.         super.onCreate(savedInstanceState);
  5.         //R.layout.xxx为引入自定义xml布局文件xxx.xml
  6.         setContentView(R.layout.xxx);
  7.     }
  8. 	......
  9. }

针对上面setContentView(R.layout.xxx);的使用，作为Android APP开发者来说，深入骨髓的说法已经不为过了，但是就这么一个方法，是怎么生成上图描述的UI层级结构的？
这就是我们今天的核心目标，我们将以源码分析的方式进行深度学习。

setContentView(R.layout.xxx)
 

  1. /**
  2.  * Set the activity content from a layout resource.  The resource will be
  3.  * inflated, adding all top-level views to the activity.
  4.  * 译文：从布局资源中设置Activity的视图内容，该资源将会被inflated并且把所有的顶层视图添加到Activity中
  5.  * @param layoutResID Resource ID to be inflated.
  6.  *
  7.  * @see #setContentView(android.view.View)
  8.  * @see #setContentView(android.view.View, android.view.ViewGroup.LayoutParams)
  9.  */
  10. public void setContentView(@LayoutRes int layoutResID) {
  11.     getWindow().setContentView(layoutResID);
  12.     initWindowDecorActionBar();//这是一个ActionBar的创建过程，暂不参与本次流程学习
  13. }

getWindow().setContentView(layoutResID);引出了一个Window类

android.view.PhoneWindow

android.view.PhoneWindow：Window（抽象类）的唯一实现类

  1. /**
  2.  * Abstract base class for a top-level window look and behavior policy.  An
  3.  * instance of this class should be used as the top-level view added to the
  4.  * window manager. It provides standard UI policies such as a background, title
  5.  * area, default key processing, etc.
  6.  * 译文：顶层窗口外观和行为策略的抽象基类。这个类的一个实例应该用作添加到窗口管理器的顶级视图。
  7.  * 
  8.  * 它提供了标准的UI策略，如背景、标题区域、默认键处理等
  9.  * <p>The only existing implementation of this abstract class is
  10.  * android.view.PhoneWindow, which you should instantiate when needing a
  11.  * Window.
  12.  * 译文：android.view.PhoneWindow是该抽象类的唯一实现类，你在需要一个Window时应该实例
  13.  */
  14. public abstract class Window {
  15. 	......
  16. }

根据Window的类注释，针对getWindow().setContentView(layoutResID)的调用，我们应该到PhoneWindow中阅读setContentView方法的实现内容

  1. @Override
  2. public void setContentView(int layoutResID) {
  3.     // Note: FEATURE_CONTENT_TRANSITIONS may be set in the process of installing the window
  4.     // decor, when theme attributes and the like are crystalized. Do not check the feature
  5.     // before this happens.
  6.     if (mContentParent == null) {
  7.         installDecor();
  8.     } else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
  9.         mContentParent.removeAllViews();
  10.     }
  11.  
  12.     if (hasFeature(FEATURE_CONTENT_TRANSITIONS)) {//执行动画相关操作
  13.         final Scene newScene = Scene.getSceneForLayout(mContentParent, layoutResID,
  14.                 getContext());
  15.         transitionTo(newScene);
  16.     } else {
  17.     	//layoutResID是一个xml布局，它将在这里被添加到mContentParent这个容器中，最后进行View视图的显示
  18.         mLayoutInflater.inflate(layoutResID, mContentParent);
  19.     }
  20.     mContentParent.requestApplyInsets();
  21.     final Callback cb = getCallback();
  22.     if (cb != null && !isDestroyed()) {
  23.         cb.onContentChanged();
  24.     }
  25.     mContentParentExplicitlySet = true;
  26. }

PhoneWindow的实例化过程

在Activity中attach方法内的第 12 行，PhoneWindow以New的方式被实例化成mWindow对象

  1.     final void attach(Context context, ActivityThread aThread,
  2.             Instrumentation instr, IBinder token, int ident,
  3.             Application application, Intent intent, ActivityInfo info,
  4.             CharSequence title, Activity parent, String id,
  5.             NonConfigurationInstances lastNonConfigurationInstances,
  6.             Configuration config, String referrer, IVoiceInteractor voiceInteractor,
  7.             Window window, ActivityConfigCallback activityConfigCallback) {
  8.         attachBaseContext(context);
  9.  
  10.         mFragments.attachHost(null /*parent*/);
  11. 		//PhoneWindow 在这里被实例化出来了
  12.         mWindow = new PhoneWindow(this, window, activityConfigCallback);
  13.         mWindow.setWindowControllerCallback(this);
  14.         mWindow.setCallback(this);
  15.         mWindow.setOnWindowDismissedCallback(this);
  16.         mWindow.getLayoutInflater().setPrivateFactory(this);
  17.         ......
  18.         /*并且在以下代码中，我们可以发现到Activity的相关生命周期的调用*/
  19.         activity.mCalled = false;
  20.         if (r.isPersistable()) {
  21.             mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
  22.         } else {
  23.             mInstrumentation.callActivityOnCreate(activity, r.state);
  24.         }
  25.         if (!activity.mCalled) {
  26.             throw new SuperNotCalledException(
  27.                 "Activity " + r.intent.getComponent().toShortString() +
  28.                 " did not call through to super.onCreate()");
  29.         }
  30.         r.activity = activity;
  31.         r.stopped = true;
  32.         if (!r.activity.mFinished) {
  33.             activity.performStart();
  34.             r.stopped = false;
  35.         }
  36.         if (!r.activity.mFinished) {
  37.             if (r.isPersistable()) {
  38.                 if (r.state != null || r.persistentState != null) {
  39.                     mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,
  40.                             r.persistentState);
  41.                 }
  42.             } else if (r.state != null) {
  43.                 mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
  44.             }
  45.         }
  46.         if (!r.activity.mFinished) {
  47.             activity.mCalled = false;
  48.             if (r.isPersistable()) {
  49.                 mInstrumentation.callActivityOnPostCreate(activity, r.state,
  50.                         r.persistentState);
  51.             } else {
  52.                 mInstrumentation.callActivityOnPostCreate(activity, r.state);
  53.             }
  54.             if (!activity.mCalled) {
  55.                 throw new SuperNotCalledException(
  56.                     "Activity " + r.intent.getComponent().toShortString() +
  57.                     " did not call through to super.onPostCreate()");
  58.             }
  59.         }
  60.     }

而attach则是在ActivityThread类中的performLaunchActivity被调用

  1.     private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
  2.         // System.out.println("##### [" + System.currentTimeMillis() + "] ActivityThread.performLaunchActivity(" + r + ")");
  3.  
  4.         ......
  5.         Activity activity = null;
  6.         ......
  7.  
  8.         try {
  9.             Application app = r.packageInfo.makeApplication(false, mInstrumentation);
  10.  
  11.             ......
  12.  
  13.             if (activity != null) {
  14.                 ......
  15.                 appContext.setOuterContext(activity);
  16.                 //这里调用了Activity的attach方法，实现了PhoneWindow的初始化
  17.                 activity.attach(appContext, this, getInstrumentation(), r.token,
  18.                         r.ident, app, r.intent, r.activityInfo, title, r.parent,
  19.                         r.embeddedID, r.lastNonConfigurationInstances, config,
  20.                         r.referrer, r.voiceInteractor, window, r.configCallback);
  21.  
  22.                 ......
  23.             }
  24.             r.paused = true;
  25.  
  26.             mActivities.put(r.token, r);
  27.  
  28.         } catch (SuperNotCalledException e) {
  29.             throw e;
  30.  
  31.         } catch (Exception e) {
  32.             if (!mInstrumentation.onException(activity, e)) {
  33.                 throw new RuntimeException(
  34.                     "Unable to start activity " + component
  35.                     + ": " + e.toString(), e);
  36.             }
  37.         }
  38.  
  39.         return activity;
  40.     }

DecorView如何添加到Window窗口

在这里插入图片描述

关注点1：requestFeature(int featureId)

  1. // Note: FEATURE_CONTENT_TRANSITIONS may be set in the process of installing the window
  2. // decor, when theme attributes and the like are crystalized. Do not check the feature
  3. // before this happens.

 

该处是一处备注说明，大致意思为：
当主题属性和类似的东西被具体化时，Window在被加载的过程中可能被设置FEATURE_CONTENT_TRANSITIONS，在此之前不要检测该feature属性
该处也正是说明了为什么我们在使用Window的requestFeature(int featureId)函数必须在setContentView之前才有用，并且在下面还会进一步分析这个条件

关注点2：mContentParent
在第 6 行代码中，我们关注到了if (mContentParent == null)的判空条件，那么mContentParent就应该是一个值得关注的对象，那么它是个什么对象呢

  1. // This is the view in which the window contents are placed. It is either
  2. // mDecor itself, or a child of mDecor where the contents go.
  3. ViewGroup mContentParent;

它是一个ViewGroup容器，并且注释写的很清楚：
这是放置Window内容的视图。它要么是mDecor本身，要么是mDecor的子内容。
接地气一点的意思就是：mContentParent就是用来加载我们想要的xml布局内容的容器
其中注释提及到了mDecor，并且在第 7 行的installDecor();方法内也体现到了mDecor对象

关注点3：mDecor
 

  1. // This is the top-level view of the window, containing the window decor.
  2. private DecorView mDecor;
  1. /** @hide */
  2. public class DecorView extends FrameLayout implements RootViewSurfaceTaker, WindowCallbacks {
  3. 	......
  4. }

对mDecor的分析结果就是：mDecor是Window窗口视图的根节点，它继承了FrameLayout容器

关注点4：FEATURE_CONTENT_TRANSITIONS
FEATURE_CONTENT_TRANSITIONS是Activity的转场动画，就是用来设置动画操作的标志

关注点5：mLayoutInflater.inflate(layoutResID, mContentParent);
layoutResID是一个xml布局，取决于feature值所对应的布局文件，它将在这里被添加到mContentParent这个容器中，最后进行View视图的显示

结合关注点1-5源码分析

installDecor()

  1. if (mContentParent == null) {
  2.     installDecor();
  3. } else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
  4.     mContentParent.removeAllViews();
  5. }

如果mContentParent != nulll的时候，那么这里会清空容器中的所有View -> mContentParent.removeAllViews();
那么为null的时候，installDecor();初始化了什么内容

  1. private void installDecor() {
  2.     mForceDecorInstall = false;
  3.     if (mDecor == null) {
  4.         mDecor = generateDecor(-1);//实例出一个DecorView对象
  5.         mDecor.setDescendantFocusability(ViewGroup.FOCUS_AFTER_DESCENDANTS);
  6.         mDecor.setIsRootNamespace(true);
  7.         if (!mInvalidatePanelMenuPosted && mInvalidatePanelMenuFeatures != 0) {
  8.             mDecor.postOnAnimation(mInvalidatePanelMenuRunnable);
  9.         }
  10.     } else {
  11.         mDecor.setWindow(this);
  12.     }
  13.     if (mContentParent == null) {
  14.         mContentParent = generateLayout(mDecor);
  15.  
  16.         // Set up decor part of UI to ignore fitsSystemWindows if appropriate.
  17.         mDecor.makeOptionalFitsSystemWindows();
  18.  
  19.         final DecorContentParent decorContentParent = (DecorContentParent) mDecor.findViewById(
  20.                 R.id.decor_content_parent);
  21.  
  22.         if (decorContentParent != null) {
  23.             mDecorContentParent = decorContentParent;
  24.             mDecorContentParent.setWindowCallback(getCallback());
  25.             if (mDecorContentParent.getTitle() == null) {
  26.                 mDecorContentParent.setWindowTitle(mTitle);
  27.             }
  28.  
  29.             final int localFeatures = getLocalFeatures();
  30.             for (int i = 0; i < FEATURE_MAX; i++) {
  31.                 if ((localFeatures & (1 << i)) != 0) {
  32.                     mDecorContentParent.initFeature(i);
  33.                 }
  34.             }
  35.  
  36.             mDecorContentParent.setUiOptions(mUiOptions);
  37.  
  38.             if ((mResourcesSetFlags & FLAG_RESOURCE_SET_ICON) != 0 ||
  39.                     (mIconRes != 0 && !mDecorContentParent.hasIcon())) {
  40.                 mDecorContentParent.setIcon(mIconRes);
  41.             } else if ((mResourcesSetFlags & FLAG_RESOURCE_SET_ICON) == 0 &&
  42.                     mIconRes == 0 && !mDecorContentParent.hasIcon()) {
  43.                 mDecorContentParent.setIcon(
  44.                         getContext().getPackageManager().getDefaultActivityIcon());
  45.                 mResourcesSetFlags |= FLAG_RESOURCE_SET_ICON_FALLBACK;
  46.             }
  47.             if ((mResourcesSetFlags & FLAG_RESOURCE_SET_LOGO) != 0 ||
  48.                     (mLogoRes != 0 && !mDecorContentParent.hasLogo())) {
  49.                 mDecorContentParent.setLogo(mLogoRes);
  50.             }
  51.  
  52.             // Invalidate if the panel menu hasn't been created before this.
  53.             // Panel menu invalidation is deferred avoiding application onCreateOptionsMenu
  54.             // being called in the middle of onCreate or similar.
  55.             // A pending invalidation will typically be resolved before the posted message
  56.             // would run normally in order to satisfy instance state restoration.
  57.             PanelFeatureState st = getPanelState(FEATURE_OPTIONS_PANEL, false);
  58.             if (!isDestroyed() && (st == null || st.menu == null) && !mIsStartingWindow) {
  59.                 invalidatePanelMenu(FEATURE_ACTION_BAR);
  60.             }
  61.         } else {
  62.             mTitleView = findViewById(R.id.title);
  63.             if (mTitleView != null) {
  64.                 if ((getLocalFeatures() & (1 << FEATURE_NO_TITLE)) != 0) {
  65.                     final View titleContainer = findViewById(R.id.title_container);
  66.                     if (titleContainer != null) {
  67.                         titleContainer.setVisibility(View.GONE);
  68.                     } else {
  69.                         mTitleView.setVisibility(View.GONE);
  70.                     }
  71.                     mContentParent.setForeground(null);
  72.                 } else {
  73.                     mTitleView.setText(mTitle);
  74.                 }
  75.             }
  76.         }
  77.  
  78.         if (mDecor.getBackground() == null && mBackgroundFallbackResource != 0) {
  79.             mDecor.setBackgroundFallback(mBackgroundFallbackResource);
  80.         }
  81.  
  82.         // Only inflate or create a new TransitionManager if the caller hasn't
  83.         // already set a custom one.
  84.         if (hasFeature(FEATURE_ACTIVITY_TRANSITIONS)) {
  85.             if (mTransitionManager == null) {
  86.                 final int transitionRes = getWindowStyle().getResourceId(
  87.                         R.styleable.Window_windowContentTransitionManager,
  88.                         0);
  89.                 if (transitionRes != 0) {
  90.                     final TransitionInflater inflater = TransitionInflater.from(getContext());
  91.                     mTransitionManager = inflater.inflateTransitionManager(transitionRes,
  92.                             mContentParent);
  93.                 } else {
  94.                     mTransitionManager = new TransitionManager();
  95.                 }
  96.             }
  97.  
  98.             mEnterTransition = getTransition(mEnterTransition, null,
  99.                     R.styleable.Window_windowEnterTransition);
  100.             mReturnTransition = getTransition(mReturnTransition, USE_DEFAULT_TRANSITION,
  101.                     R.styleable.Window_windowReturnTransition);
  102.             mExitTransition = getTransition(mExitTransition, null,
  103.                     R.styleable.Window_windowExitTransition);
  104.             mReenterTransition = getTransition(mReenterTransition, USE_DEFAULT_TRANSITION,
  105.                     R.styleable.Window_windowReenterTransition);
  106.             mSharedElementEnterTransition = getTransition(mSharedElementEnterTransition, null,
  107.                     R.styleable.Window_windowSharedElementEnterTransition);
  108.             mSharedElementReturnTransition = getTransition(mSharedElementReturnTransition,
  109.                     USE_DEFAULT_TRANSITION,
  110.                     R.styleable.Window_windowSharedElementReturnTransition);
  111.             mSharedElementExitTransition = getTransition(mSharedElementExitTransition, null,
  112.                     R.styleable.Window_windowSharedElementExitTransition);
  113.             mSharedElementReenterTransition = getTransition(mSharedElementReenterTransition,
  114.                     USE_DEFAULT_TRANSITION,
  115.                     R.styleable.Window_windowSharedElementReenterTransition);
  116.             if (mAllowEnterTransitionOverlap == null) {
  117.                 mAllowEnterTransitionOverlap = getWindowStyle().getBoolean(
  118.                         R.styleable.Window_windowAllowEnterTransitionOverlap, true);
  119.             }
  120.             if (mAllowReturnTransitionOverlap == null) {
  121.                 mAllowReturnTransitionOverlap = getWindowStyle().getBoolean(
  122.                         R.styleable.Window_windowAllowReturnTransitionOverlap, true);
  123.             }
  124.             if (mBackgroundFadeDurationMillis < 0) {
  125.                 mBackgroundFadeDurationMillis = getWindowStyle().getInteger(
  126.                         R.styleable.Window_windowTransitionBackgroundFadeDuration,
  127.                         DEFAULT_BACKGROUND_FADE_DURATION_MS);
  128.             }
  129.             if (mSharedElementsUseOverlay == null) {
  130.                 mSharedElementsUseOverlay = getWindowStyle().getBoolean(
  131.                         R.styleable.Window_windowSharedElementsUseOverlay, true);
  132.             }
  133.         }
  134.     }
  135. }

mDecor = generateDecor(-1)

  1. 在installDecor()中的第 4 行中，mDecor = generateDecor(-1);实例了一个DecorView对象mDecor
  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, getContext().getResources());
  12.                 if (mTheme != -1) {
  13.                     context.setTheme(mTheme);
  14.                 }
  15.             }
  16.         } else {
  17.             context = getContext();
  18.         }
  19.         return new DecorView(context, featureId, this, getAttributes());//以new的方式实例出了一个DecorView对象
  20.     }

并在installDecor()中的第 14 行中mContentParent = generateLayout(mDecor);把实例出来的mDecor对象带入后实例出了一个mContentParent 容器对象

mContentParent = generateLayout(mDecor)
方法内容总结：

获取有关Window的Style属性，是否浮窗（Floating）类型、主题（windowNoTitle与windowActionBar）、全屏（windowFullscreen）、Window透明情况等
对相关Window的Style属性设置requestFeature、setFlags等信息
根据 int features = getLocalFeatures();取得的features属性值，加载对应的DecorView布局容器（layoutResource）
NOTES：这里也验证了对requestFeature设置的属性，是在这里被使用到的，而这里是在setContentView流程中，所以requestFeature设置就必须在setContentView之前！
返回以features属性对应的DecorView布局容器中用来存放用户自定义的xml布局容器mContentParent对象
 

  1. protected ViewGroup generateLayout(DecorView decor) {
  2.     // Apply data from current theme.
  3.  
  4. 	//1.加载Window相关的Style属性：当我们在xml中设置一下Style属性之后，就是在这里进行加载
  5.     TypedArray a = getWindowStyle();
  6.  
  7.     if (false) {
  8.         System.out.println("From style:");
  9.         String s = "Attrs:";
  10.         for (int i = 0; i < R.styleable.Window.length; i++) {
  11.             s = s + " " + Integer.toHexString(R.styleable.Window[i]) + "="
  12.                     + a.getString(i);
  13.         }
  14.         System.out.println(s);
  15.     }
  16. 	//2.判断当前 Window 是不是浮窗类型的，比如 Dialog
  17.     mIsFloating = a.getBoolean(R.styleable.Window_windowIsFloating, false);
  18.     int flagsToUpdate = (FLAG_LAYOUT_IN_SCREEN|FLAG_LAYOUT_INSET_DECOR)
  19.             & (~getForcedWindowFlags());
  20.     if (mIsFloating) {
  21.         setLayout(WRAP_CONTENT, WRAP_CONTENT);
  22.         setFlags(0, flagsToUpdate);
  23.     } else {
  24.         setFlags(FLAG_LAYOUT_IN_SCREEN|FLAG_LAYOUT_INSET_DECOR, flagsToUpdate);
  25.     }
  26. 	//3.设置 requestFeature、setFlags，处理设置的 Window 的主题Style属性值，并且 windowNoTitle 与 windowActionBar 互斥
  27.     if (a.getBoolean(R.styleable.Window_windowNoTitle, false)) {
  28.         requestFeature(FEATURE_NO_TITLE);
  29.     } else if (a.getBoolean(R.styleable.Window_windowActionBar, false)) {
  30.         // Don't allow an action bar if there is no title.
  31.         requestFeature(FEATURE_ACTION_BAR);
  32.     }
  33.  
  34.     if (a.getBoolean(R.styleable.Window_windowActionBarOverlay, false)) {
  35.         requestFeature(FEATURE_ACTION_BAR_OVERLAY);
  36.     }
  37.  
  38.     if (a.getBoolean(R.styleable.Window_windowActionModeOverlay, false)) {
  39.         requestFeature(FEATURE_ACTION_MODE_OVERLAY);
  40.     }
  41.  
  42.     if (a.getBoolean(R.styleable.Window_windowSwipeToDismiss, false)) {
  43.         requestFeature(FEATURE_SWIPE_TO_DISMISS);
  44.     }
  45.  
  46.     if (a.getBoolean(R.styleable.Window_windowFullscreen, false)) {
  47.         setFlags(FLAG_FULLSCREEN, FLAG_FULLSCREEN & (~getForcedWindowFlags()));
  48.     }
  49.  
  50.     if (a.getBoolean(R.styleable.Window_windowTranslucentStatus,
  51.             false)) {
  52.         setFlags(FLAG_TRANSLUCENT_STATUS, FLAG_TRANSLUCENT_STATUS
  53.                 & (~getForcedWindowFlags()));
  54.     }
  55.  
  56.     if (a.getBoolean(R.styleable.Window_windowTranslucentNavigation,
  57.             false)) {
  58.         setFlags(FLAG_TRANSLUCENT_NAVIGATION, FLAG_TRANSLUCENT_NAVIGATION
  59.                 & (~getForcedWindowFlags()));
  60.     }
  61.  
  62.     if (a.getBoolean(R.styleable.Window_windowOverscan, false)) {
  63.         setFlags(FLAG_LAYOUT_IN_OVERSCAN, FLAG_LAYOUT_IN_OVERSCAN&(~getForcedWindowFlags()));
  64.     }
  65.  
  66.     if (a.getBoolean(R.styleable.Window_windowShowWallpaper, false)) {
  67.         setFlags(FLAG_SHOW_WALLPAPER, FLAG_SHOW_WALLPAPER&(~getForcedWindowFlags()));
  68.     }
  69.  
  70.     if (a.getBoolean(R.styleable.Window_windowEnableSplitTouch,
  71.             getContext().getApplicationInfo().targetSdkVersion
  72.                     >= android.os.Build.VERSION_CODES.HONEYCOMB)) {
  73.         setFlags(FLAG_SPLIT_TOUCH, FLAG_SPLIT_TOUCH&(~getForcedWindowFlags()));
  74.     }
  75.  
  76.     a.getValue(R.styleable.Window_windowMinWidthMajor, mMinWidthMajor);
  77.     a.getValue(R.styleable.Window_windowMinWidthMinor, mMinWidthMinor);
  78.     if (DEBUG) Log.d(TAG, "Min width minor: " + mMinWidthMinor.coerceToString()
  79.             + ", major: " + mMinWidthMajor.coerceToString());
  80.     if (a.hasValue(R.styleable.Window_windowFixedWidthMajor)) {
  81.         if (mFixedWidthMajor == null) mFixedWidthMajor = new TypedValue();
  82.         a.getValue(R.styleable.Window_windowFixedWidthMajor,
  83.                 mFixedWidthMajor);
  84.     }
  85.     if (a.hasValue(R.styleable.Window_windowFixedWidthMinor)) {
  86.         if (mFixedWidthMinor == null) mFixedWidthMinor = new TypedValue();
  87.         a.getValue(R.styleable.Window_windowFixedWidthMinor,
  88.                 mFixedWidthMinor);
  89.     }
  90.     if (a.hasValue(R.styleable.Window_windowFixedHeightMajor)) {
  91.         if (mFixedHeightMajor == null) mFixedHeightMajor = new TypedValue();
  92.         a.getValue(R.styleable.Window_windowFixedHeightMajor,
  93.                 mFixedHeightMajor);
  94.     }
  95.     if (a.hasValue(R.styleable.Window_windowFixedHeightMinor)) {
  96.         if (mFixedHeightMinor == null) mFixedHeightMinor = new TypedValue();
  97.         a.getValue(R.styleable.Window_windowFixedHeightMinor,
  98.                 mFixedHeightMinor);
  99.     }
  100.     if (a.getBoolean(R.styleable.Window_windowContentTransitions, false)) {
  101.         requestFeature(FEATURE_CONTENT_TRANSITIONS);
  102.     }
  103.     if (a.getBoolean(R.styleable.Window_windowActivityTransitions, false)) {
  104.         requestFeature(FEATURE_ACTIVITY_TRANSITIONS);
  105.     }
  106. 	//4.Window 是否透明属性
  107.     mIsTranslucent = a.getBoolean(R.styleable.Window_windowIsTranslucent, false);
  108.  
  109.     final Context context = getContext();
  110.     final int targetSdk = context.getApplicationInfo().targetSdkVersion;
  111.     final boolean targetPreHoneycomb = targetSdk < android.os.Build.VERSION_CODES.HONEYCOMB;
  112.     final boolean targetPreIcs = targetSdk < android.os.Build.VERSION_CODES.ICE_CREAM_SANDWICH;
  113.     final boolean targetPreL = targetSdk < android.os.Build.VERSION_CODES.LOLLIPOP;
  114.     final boolean targetHcNeedsOptions = context.getResources().getBoolean(
  115.             R.bool.target_honeycomb_needs_options_menu);
  116.     final boolean noActionBar = !hasFeature(FEATURE_ACTION_BAR) || hasFeature(FEATURE_NO_TITLE);
  117.  
  118.     if (targetPreHoneycomb || (targetPreIcs && targetHcNeedsOptions && noActionBar)) {
  119.         setNeedsMenuKey(WindowManager.LayoutParams.NEEDS_MENU_SET_TRUE);
  120.     } else {
  121.         setNeedsMenuKey(WindowManager.LayoutParams.NEEDS_MENU_SET_FALSE);
  122.     }
  123.  
  124.     if (!mForcedStatusBarColor) {
  125.         mStatusBarColor = a.getColor(R.styleable.Window_statusBarColor, 0xFF000000);
  126.     }
  127.     if (!mForcedNavigationBarColor) {
  128.         mNavigationBarColor = a.getColor(R.styleable.Window_navigationBarColor, 0xFF000000);
  129.     }
  130.  
  131.     WindowManager.LayoutParams params = getAttributes();
  132.  
  133.     // Non-floating windows on high end devices must put up decor beneath the system bars and
  134.     // therefore must know about visibility changes of those.
  135.     if (!mIsFloating && ActivityManager.isHighEndGfx()) {
  136.         if (!targetPreL && a.getBoolean(
  137.                 R.styleable.Window_windowDrawsSystemBarBackgrounds,
  138.                 false)) {
  139.             setFlags(FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS,
  140.                     FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS & ~getForcedWindowFlags());
  141.         }
  142.         if (mDecor.mForceWindowDrawsStatusBarBackground) {
  143.             params.privateFlags |= PRIVATE_FLAG_FORCE_DRAW_STATUS_BAR_BACKGROUND;
  144.         }
  145.     }
  146.     if (a.getBoolean(R.styleable.Window_windowLightStatusBar, false)) {
  147.         decor.setSystemUiVisibility(
  148.                 decor.getSystemUiVisibility() | View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR);
  149.     }
  150.  
  151.     if (mAlwaysReadCloseOnTouchAttr || getContext().getApplicationInfo().targetSdkVersion
  152.             >= android.os.Build.VERSION_CODES.HONEYCOMB) {
  153.         if (a.getBoolean(
  154.                 R.styleable.Window_windowCloseOnTouchOutside,
  155.                 false)) {
  156.             setCloseOnTouchOutsideIfNotSet(true);
  157.         }
  158.     }
  159.  
  160.     if (!hasSoftInputMode()) {
  161.         params.softInputMode = a.getInt(
  162.                 R.styleable.Window_windowSoftInputMode,
  163.                 params.softInputMode);
  164.     }
  165.  
  166.     if (a.getBoolean(R.styleable.Window_backgroundDimEnabled,
  167.             mIsFloating)) {
  168.         /* All dialogs should have the window dimmed */
  169.         if ((getForcedWindowFlags()&WindowManager.LayoutParams.FLAG_DIM_BEHIND) == 0) {
  170.             params.flags |= WindowManager.LayoutParams.FLAG_DIM_BEHIND;
  171.         }
  172.         if (!haveDimAmount()) {
  173.             params.dimAmount = a.getFloat(
  174.                     android.R.styleable.Window_backgroundDimAmount, 0.5f);
  175.         }
  176.     }
  177.  
  178.     if (params.windowAnimations == 0) {
  179.         params.windowAnimations = a.getResourceId(
  180.                 R.styleable.Window_windowAnimationStyle, 0);
  181.     }
  182.  
  183.     // The rest are only done if this window is not embedded; otherwise,
  184.     // the values are inherited from our container.
  185.     if (getContainer() == null) {
  186.         if (mBackgroundDrawable == null) {
  187.             if (mBackgroundResource == 0) {
  188.                 mBackgroundResource = a.getResourceId(
  189.                         R.styleable.Window_windowBackground, 0);
  190.             }
  191.             if (mFrameResource == 0) {
  192.                 mFrameResource = a.getResourceId(R.styleable.Window_windowFrame, 0);
  193.             }
  194.             mBackgroundFallbackResource = a.getResourceId(
  195.                     R.styleable.Window_windowBackgroundFallback, 0);
  196.             if (false) {
  197.                 System.out.println("Background: "
  198.                         + Integer.toHexString(mBackgroundResource) + " Frame: "
  199.                         + Integer.toHexString(mFrameResource));
  200.             }
  201.         }
  202.         if (mLoadElevation) {
  203.             mElevation = a.getDimension(R.styleable.Window_windowElevation, 0);
  204.         }
  205.         mClipToOutline = a.getBoolean(R.styleable.Window_windowClipToOutline, false);
  206.         mTextColor = a.getColor(R.styleable.Window_textColor, Color.TRANSPARENT);
  207.     }
  208.  
  209.     // Inflate the window decor. 生成对应的 Window decor
  210.  
  211.     int layoutResource;
  212.     //5.在这里获取设置好的feature属性值，然后根据features值初始化对应的DecorView容器布局，
  213.     //同时说明在调用Window.requestFeature方法时，必须在setContentView之前，
  214.     int features = getLocalFeatures();
  215.     // System.out.println("Features: 0x" + Integer.toHexString(features));
  216.     if ((features & (1 << FEATURE_SWIPE_TO_DISMISS)) != 0) {
  217.         layoutResource = R.layout.screen_swipe_dismiss;
  218.         setCloseOnSwipeEnabled(true);
  219.     } else if ((features & ((1 << FEATURE_LEFT_ICON) | (1 << FEATURE_RIGHT_ICON))) != 0) {
  220.         if (mIsFloating) {
  221.             TypedValue res = new TypedValue();
  222.             getContext().getTheme().resolveAttribute(
  223.                     R.attr.dialogTitleIconsDecorLayout, res, true);
  224.             layoutResource = res.resourceId;
  225.         } else {
  226.             layoutResource = R.layout.screen_title_icons;
  227.         }
  228.         // XXX Remove this once action bar supports these features.
  229.         removeFeature(FEATURE_ACTION_BAR);
  230.         // System.out.println("Title Icons!");
  231.     } else if ((features & ((1 << FEATURE_PROGRESS) | (1 << FEATURE_INDETERMINATE_PROGRESS))) != 0
  232.             && (features & (1 << FEATURE_ACTION_BAR)) == 0) {
  233.         // Special case for a window with only a progress bar (and title).
  234.         // XXX Need to have a no-title version of embedded windows.
  235.         layoutResource = R.layout.screen_progress;
  236.         // System.out.println("Progress!");
  237.     } else if ((features & (1 << FEATURE_CUSTOM_TITLE)) != 0) {
  238.         // Special case for a window with a custom title.
  239.         // If the window is floating, we need a dialog layout
  240.         if (mIsFloating) {
  241.             TypedValue res = new TypedValue();
  242.             getContext().getTheme().resolveAttribute(
  243.                     R.attr.dialogCustomTitleDecorLayout, res, true);
  244.             layoutResource = res.resourceId;
  245.         } else {
  246.             layoutResource = R.layout.screen_custom_title;
  247.         }
  248.         // XXX Remove this once action bar supports these features.
  249.         removeFeature(FEATURE_ACTION_BAR);
  250.     } else if ((features & (1 << FEATURE_NO_TITLE)) == 0) {
  251.         // If no other features and not embedded, only need a title.
  252.         // If the window is floating, we need a dialog layout
  253.         if (mIsFloating) {
  254.             TypedValue res = new TypedValue();
  255.             getContext().getTheme().resolveAttribute(
  256.                     R.attr.dialogTitleDecorLayout, res, true);
  257.             layoutResource = res.resourceId;
  258.         } else if ((features & (1 << FEATURE_ACTION_BAR)) != 0) {
  259.             layoutResource = a.getResourceId(
  260.                     R.styleable.Window_windowActionBarFullscreenDecorLayout,
  261.                     R.layout.screen_action_bar);
  262.         } else {
  263.             layoutResource = R.layout.screen_title;
  264.         }
  265.         // System.out.println("Title!");
  266.     } else if ((features & (1 << FEATURE_ACTION_MODE_OVERLAY)) != 0) {
  267.         layoutResource = R.layout.screen_simple_overlay_action_mode;
  268.     } else {
  269.         // Embedded, so no decoration is needed.
  270.         layoutResource = R.layout.screen_simple;
  271.         // System.out.println("Simple!");
  272.     }
  273.  
  274.     mDecor.startChanging();
  275.     //加载DecorView布局文件
  276.     mDecor.onResourcesLoaded(mLayoutInflater, layoutResource);
  277. 	//实例mDecor布局中id为content的容器：public static final int ID_ANDROID_CONTENT = com.android.internal.R.id.content;
  278.     ViewGroup contentParent = (ViewGroup)findViewById(ID_ANDROID_CONTENT);
  279.     if (contentParent == null) {
  280.         throw new RuntimeException("Window couldn't find content container view");
  281.     }
  282.  
  283.     if ((features & (1 << FEATURE_INDETERMINATE_PROGRESS)) != 0) {
  284.         ProgressBar progress = getCircularProgressBar(false);
  285.         if (progress != null) {
  286.             progress.setIndeterminate(true);
  287.         }
  288.     }
  289.  
  290.     if ((features & (1 << FEATURE_SWIPE_TO_DISMISS)) != 0) {
  291.         registerSwipeCallbacks(contentParent);
  292.     }
  293.  
  294.     // Remaining setup -- of background and title -- that only applies
  295.     // to top-level windows.
  296.     if (getContainer() == null) {
  297.         final Drawable background;
  298.         if (mBackgroundResource != 0) {
  299.             background = getContext().getDrawable(mBackgroundResource);
  300.         } else {
  301.             background = mBackgroundDrawable;
  302.         }
  303.         mDecor.setWindowBackground(background);
  304.  
  305.         final Drawable frame;
  306.         if (mFrameResource != 0) {
  307.             frame = getContext().getDrawable(mFrameResource);
  308.         } else {
  309.             frame = null;
  310.         }
  311.         mDecor.setWindowFrame(frame);
  312.  
  313.         mDecor.setElevation(mElevation);
  314.         mDecor.setClipToOutline(mClipToOutline);
  315.  
  316.         if (mTitle != null) {
  317.             setTitle(mTitle);
  318.         }
  319.  
  320.         if (mTitleColor == 0) {
  321.             mTitleColor = mTextColor;
  322.         }
  323.         setTitleColor(mTitleColor);
  324.     }
  325.  
  326.     mDecor.finishChanging();
  327.  
  328.     return contentParent;
  329. }

到此，基于一开始抛出的Activity UI层级结构图便已清晰的深入剖析。并且得知了最后开发者在setContentView中设置的xml布局文件，最终都是被inflated到mContentParent这个ViewGroup中的。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/511705
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号