Android Activity从创建到显示流程

ゞ浴缸里的玫瑰 2022-05-08 14:46 156阅读 0赞

看我的代码请注意写了注释的地方,这些往往是关键地方

最近准备看Android的View工作流程,但是根据网上的博客所说,必然就会涉及到Window,DecorView,WindowManager,ViewRootImpl这些相关的东西,所以在网络上众多大神博客的指导下去阅读了Android的部分源码,  
发现Android的很多东西还都是一环套一环的,有些东西单单只是看部分代码就会云里雾里,一脸懵逼.结合我原来看Handler机制源码的经验就先从Activity的启动开始看起,诸位请随我看下去

Activty是在ActivtyThread的中创建的,简单说下ActivtyThread,这个类就是我们app的入口,然后有着我们在学习Java的时候常见的main方法,里面有一个Looper循环,保持主线程不死.Activity的创建在ActivtyThread内部H类中,H类继承自Handler,里面处理了众多Android系统的事件,其中就包括Activity的启动创建

//此处只贴部分代码,完整代码请自行查看Android源码
        case LAUNCH_ACTIVITY: {
        
                        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
                        final ActivityClientRecord r = (ActivityClientRecord) msg.obj;
    
                        r.packageInfo = getPackageInfoNoCheck(
                                r.activityInfo.applicationInfo, r.compatInfo);
                        handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
                        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    } break;

//操作启动Activity
        private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
        
            // If we are getting ready to gc after going to the background, well
            // we are back active so skip it.
            unscheduleGcIdler();
            mSomeActivitiesChanged = true;
    
            if (r.profilerInfo != null) {
        
                mProfiler.setProfiler(r.profilerInfo);
                mProfiler.startProfiling();
            }
    
            // Make sure we are running with the most recent config.
            handleConfigurationChanged(null, null);
    
            if (localLOGV) Slog.v(
                TAG, "Handling launch of " + r);
    
            // Initialize before creating the activity
            if (!ThreadedRenderer.sRendererDisabled) {
        
                GraphicsEnvironment.earlyInitEGL();
            }
            WindowManagerGlobal.initialize();
    
            Activity a = performLaunchActivity(r, customIntent);//执行启动Activity,在里面会去创建Activity,并且会执行Activity的onCreate和onStart生命周期
    
            if (a != null) {
        
                r.createdConfig = new Configuration(mConfiguration);
                reportSizeConfigurations(r);
                Bundle oldState = r.state;
                handleResumeActivity(r.token, false, r.isForward,
                        !r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);//准备执行Activty的Resume生命周期
    
                if (!r.activity.mFinished && r.startsNotResumed) {
        
                    // The activity manager actually wants this one to start out paused, because it
                    // needs to be visible but isn't in the foreground. We accomplish this by going
                    // through the normal startup (because activities expect to go through onResume()
                    // the first time they run, before their window is displayed), and then pausing it.
                    // However, in this case we do -not- need to do the full pause cycle (of freezing
                    // and such) because the activity manager assumes it can just retain the current
                    // state it has.
                    performPauseActivityIfNeeded(r, reason);
    
                    // We need to keep around the original state, in case we need to be created again.
                    // But we only do this for pre-Honeycomb apps, which always save their state when
                    // pausing, so we can not have them save their state when restarting from a paused
                    // state. For HC and later, we want to (and can) let the state be saved as the
                    // normal part of stopping the activity.
                    if (r.isPreHoneycomb()) {
        
                        r.state = oldState;
                    }
                }
            } else {
        
                // If there was an error, for any reason, tell the activity manager to stop us.
                try {
        
                    ActivityManager.getService()
                        .finishActivity(r.token, Activity.RESULT_CANCELED, null,
                                Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
                } catch (RemoteException ex) {
        
                    throw ex.rethrowFromSystemServer();
                }
            }
        }

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        
            // System.out.println("##### [" + System.currentTimeMillis() + "] ActivityThread.performLaunchActivity(" + r + ")");
    
            ActivityInfo aInfo = r.activityInfo;
            if (r.packageInfo == null) {
        
                r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
                        Context.CONTEXT_INCLUDE_CODE);
            }
    
            ComponentName component = r.intent.getComponent();
            if (component == null) {
        
                component = r.intent.resolveActivity(
                    mInitialApplication.getPackageManager());
                r.intent.setComponent(component);
            }
    
            if (r.activityInfo.targetActivity != null) {
        
                component = new ComponentName(r.activityInfo.packageName,
                        r.activityInfo.targetActivity);
            }
    
            ContextImpl appContext = createBaseContextForActivity(r);
            Activity activity = null;
            try {
        
                java.lang.ClassLoader cl = appContext.getClassLoader();
                activity = mInstrumentation.newActivity(
                        cl, component.getClassName(), r.intent);//反射创建Activity
                StrictMode.incrementExpectedActivityCount(activity.getClass());
                r.intent.setExtrasClassLoader(cl);
                r.intent.prepareToEnterProcess();
                if (r.state != null) {
        
                    r.state.setClassLoader(cl);
                }
            } catch (Exception e) {
        
                if (!mInstrumentation.onException(activity, e)) {
        
                    throw new RuntimeException(
                        "Unable to instantiate activity " + component
                        + ": " + e.toString(), e);
                }
            }
    
            try {
        
                Application app = r.packageInfo.makeApplication(false, mInstrumentation);
    
                if (localLOGV) Slog.v(TAG, "Performing launch of " + r);
                if (localLOGV) Slog.v(
                        TAG, r + ": app=" + app
                        + ", appName=" + app.getPackageName()
                        + ", pkg=" + r.packageInfo.getPackageName()
                        + ", comp=" + r.intent.getComponent().toShortString()
                        + ", dir=" + r.packageInfo.getAppDir());
    
                if (activity != null) {
        
                    CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
                    Configuration config = new Configuration(mCompatConfiguration);
                    if (r.overrideConfig != null) {
        
                        config.updateFrom(r.overrideConfig);
                    }
                    if (DEBUG_CONFIGURATION) Slog.v(TAG, "Launching activity "
                            + r.activityInfo.name + " with config " + config);
                    Window window = null;
                    if (r.mPendingRemoveWindow != null && r.mPreserveWindow) {
        
                        window = r.mPendingRemoveWindow;
                        r.mPendingRemoveWindow = null;
                        r.mPendingRemoveWindowManager = null;
                    }
                    appContext.setOuterContext(activity);
                    activity.attach(appContext, this, getInstrumentation(), r.token,
                            r.ident, app, r.intent, r.activityInfo, title, r.parent,
                            r.embeddedID, r.lastNonConfigurationInstances, config,
                            r.referrer, r.voiceInteractor, window, r.configCallback);//设置Activity所必要的相关数据,在这里面会去初始化Window和WindowManager
    
                    if (customIntent != null) {
        
                        activity.mIntent = customIntent;
                    }
                    r.lastNonConfigurationInstances = null;
                    checkAndBlockForNetworkAccess();
                    activity.mStartedActivity = false;
                    int theme = r.activityInfo.getThemeResource();
                    if (theme != 0) {
        
                        activity.setTheme(theme);
                    }
    
                    activity.mCalled = false;
                    if (r.isPersistable()) {
        
                        mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
                    } else {
        
                        mInstrumentation.callActivityOnCreate(activity, r.state);//执行Activty的onCreate
                    }
                    if (!activity.mCalled) {
        
                        throw new SuperNotCalledException(
                            "Activity " + r.intent.getComponent().toShortString() +
                            " did not call through to super.onCreate()");
                    }
                    r.activity = activity;
                    r.stopped = true;
                    if (!r.activity.mFinished) {
        
                        activity.performStart();//执行Activity的onStart
                        r.stopped = false;
                    }
                    if (!r.activity.mFinished) {
        
                        if (r.isPersistable()) {
        
                            if (r.state != null || r.persistentState != null) {
        
                                mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,
                                        r.persistentState);
                            }
                        } else if (r.state != null) {
        
                            mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
                        }
                    }
                    if (!r.activity.mFinished) {
        
                        activity.mCalled = false;
                        if (r.isPersistable()) {
        
                            mInstrumentation.callActivityOnPostCreate(activity, r.state,
                                    r.persistentState);
                        } else {
        
                            mInstrumentation.callActivityOnPostCreate(activity, r.state);
                        }
                        if (!activity.mCalled) {
        
                            throw new SuperNotCalledException(
                                "Activity " + r.intent.getComponent().toShortString() +
                                " did not call through to super.onPostCreate()");
                        }
                    }
                }
                r.paused = true;
    
                mActivities.put(r.token, r);
    
            } catch (SuperNotCalledException e) {
        
                throw e;
    
            } catch (Exception e) {
        
                if (!mInstrumentation.onException(activity, e)) {
        
                    throw new RuntimeException(
                        "Unable to start activity " + component
                        + ": " + e.toString(), e);
                }
            }
    
            return activity;
        }

在这里我们只去看一些关闭部分的代码,不会去整个的完全解析,所以,如果想完全搞懂这部分代码,请去阅读专门的博客

在上面我们简单看了一下Activity的创建和生命周期的执行流程,下面就来看下Activity的attach方法

final void attach(Context context, ActivityThread aThread,
                Instrumentation instr, IBinder token, int ident,
                Application application, Intent intent, ActivityInfo info,
                CharSequence title, Activity parent, String id,
                NonConfigurationInstances lastNonConfigurationInstances,
                Configuration config, String referrer, IVoiceInteractor voiceInteractor,
                Window window, ActivityConfigCallback activityConfigCallback) {
        
            attachBaseContext(context);
    
            mFragments.attachHost(null /*parent*/);
    
            mWindow = new PhoneWindow(this, window, activityConfigCallback);//实例化PhoneWindow对象,Window是一个抽象类,具体功能由其子类PhoneWindow实现
            mWindow.setWindowControllerCallback(this);
            mWindow.setCallback(this);
            mWindow.setOnWindowDismissedCallback(this);
            mWindow.getLayoutInflater().setPrivateFactory(this);
            if (info.softInputMode != WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED) {
        
                mWindow.setSoftInputMode(info.softInputMode);
            }
            if (info.uiOptions != 0) {
        
                mWindow.setUiOptions(info.uiOptions);
            }
            mUiThread = Thread.currentThread();
    
            mMainThread = aThread;
            mInstrumentation = instr;
            mToken = token;
            mIdent = ident;
            mApplication = application;
            mIntent = intent;
            mReferrer = referrer;
            mComponent = intent.getComponent();
            mActivityInfo = info;
            mTitle = title;
            mParent = parent;
            mEmbeddedID = id;
            mLastNonConfigurationInstances = lastNonConfigurationInstances;
            if (voiceInteractor != null) {
        
                if (lastNonConfigurationInstances != null) {
        
                    mVoiceInteractor = lastNonConfigurationInstances.voiceInteractor;
                } else {
        
                    mVoiceInteractor = new VoiceInteractor(voiceInteractor, this, this,
                            Looper.myLooper());
                }
            }
    
            mWindow.setWindowManager(
                    (WindowManager)context.getSystemService(Context.WINDOW_SERVICE),
                    mToken, mComponent.flattenToString(),
                    (info.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0);//创建WindowManager对象
            if (mParent != null) {
        
                mWindow.setContainer(mParent.getWindow());
            }
            mWindowManager = mWindow.getWindowManager();//拿到WindowManager对象
            mCurrentConfig = config;
    
            mWindow.setColorMode(info.colorMode);
        }

代码运行到attach,根据我们在上面看到Activity的生命周期执行流程就可以知道,下一步就要执行Activity的onCreate的方法了,DecorView就是在Activity的create生命周期中创建的.  
通常具体而言就是我们调用setContentView方法时创建的.

//这个就是我们调用的setContentView方法
        public void setContentView(@LayoutRes int layoutResID) {
        
            getWindow().setContentView(layoutResID);//实际上调用的PhoneWindow的setContentView方法
            initWindowDecorActionBar();
        }	
    		
        public Window getWindow() {
        
            return mWindow;//返回的就是刚刚在attach中创建的PhoneWindow
        }

下面来看下PhoneWindow的setContentView的方法

//这个方法有重载的方法,我们只需要看其中一个就可以了
        @Override
        public void setContentView(int layoutResID) {
        
            // Note: FEATURE_CONTENT_TRANSITIONS may be set in the process of installing the window
            // decor, when theme attributes and the like are crystalized. Do not check the feature
            // before this happens.
            if (mContentParent == null) {
        //mContentParent是DecorView中的布局,在初始化DecorView的同时也会初始化mContentParent
                installDecor();//初始化DecorView
            } else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
        
                mContentParent.removeAllViews();
            }
    
            if (hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
        
                final Scene newScene = Scene.getSceneForLayout(mContentParent, layoutResID,
                        getContext());
                transitionTo(newScene);
            } else {
        
                mLayoutInflater.inflate(layoutResID, mContentParent);//将要设置的布局添加到mContentParent中
            }
            mContentParent.requestApplyInsets();
            final Callback cb = getCallback();
            if (cb != null && !isDestroyed()) {
        
                cb.onContentChanged();
            }
            mContentParentExplicitlySet = true;
        }
    		
    
    	//初始化DecorView
    	private void installDecor() {
        
            mForceDecorInstall = false;
            if (mDecor == null) {
        
                mDecor = generateDecor(-1);//调用真正初始化DecorView的方法
                mDecor.setDescendantFocusability(ViewGroup.FOCUS_AFTER_DESCENDANTS);
                mDecor.setIsRootNamespace(true);
                if (!mInvalidatePanelMenuPosted && mInvalidatePanelMenuFeatures != 0) {
        
                    mDecor.postOnAnimation(mInvalidatePanelMenuRunnable);
                }
            } else {
        
                mDecor.setWindow(this);
            }
            if (mContentParent == null) {
        
                mContentParent = generateLayout(mDecor);//这个是DecorView生成之后再去获取DecorView中的主布局,也就是Activity中setContentView设置的布局
    			//......
            }
        }
    	
    	
    	//生成DecorView
        protected DecorView generateDecor(int featureId) {
        
            // System process doesn't have application context and in that case we need to directly use
            // the context we have. Otherwise we want the application context, so we don't cling to the
            // activity.
            Context context;
            if (mUseDecorContext) {
        
                Context applicationContext = getContext().getApplicationContext();
                if (applicationContext == null) {
        
                    context = getContext();
                } else {
        
                    context = new DecorContext(applicationContext, getContext().getResources());
                    if (mTheme != -1) {
        
                        context.setTheme(mTheme);
                    }
                }
            } else {
        
                context = getContext();
            }
            return new DecorView(context, featureId, this, getAttributes());//初始化
        }
    
    
    	//当调用这个方法的时候mDecor已经被初始化了
        protected DecorView generateLayout(int featureId) {
        
    	
    	    //....
    
            int layoutResource;
            int features = getLocalFeatures();
            // System.out.println("Features: 0x" + Integer.toHexString(features));
            if ((features & (1 << FEATURE_SWIPE_TO_DISMISS)) != 0) {
        
                layoutResource = R.layout.screen_swipe_dismiss;
                setCloseOnSwipeEnabled(true);
            } else if ((features & ((1 << FEATURE_LEFT_ICON) | (1 << FEATURE_RIGHT_ICON))) != 0) {
        
                if (mIsFloating) {
        
                    TypedValue res = new TypedValue();
                    getContext().getTheme().resolveAttribute(
                            R.attr.dialogTitleIconsDecorLayout, res, true);
                    layoutResource = res.resourceId;
                } else {
        
                    layoutResource = R.layout.screen_title_icons;
                }
                // XXX Remove this once action bar supports these features.
                removeFeature(FEATURE_ACTION_BAR);
                // System.out.println("Title Icons!");
            } else if ((features & ((1 << FEATURE_PROGRESS) | (1 << FEATURE_INDETERMINATE_PROGRESS))) != 0
                    && (features & (1 << FEATURE_ACTION_BAR)) == 0) {
        
                // Special case for a window with only a progress bar (and title).
                // XXX Need to have a no-title version of embedded windows.
                layoutResource = R.layout.screen_progress;
                // System.out.println("Progress!");
            } else if ((features & (1 << FEATURE_CUSTOM_TITLE)) != 0) {
        
                // Special case for a window with a custom title.
                // If the window is floating, we need a dialog layout
                if (mIsFloating) {
        
                    TypedValue res = new TypedValue();
                    getContext().getTheme().resolveAttribute(
                            R.attr.dialogCustomTitleDecorLayout, res, true);
                    layoutResource = res.resourceId;
                } else {
        
                    layoutResource = R.layout.screen_custom_title;
                }
                // XXX Remove this once action bar supports these features.
                removeFeature(FEATURE_ACTION_BAR);
            } else if ((features & (1 << FEATURE_NO_TITLE)) == 0) {
        
                // If no other features and not embedded, only need a title.
                // If the window is floating, we need a dialog layout
                if (mIsFloating) {
        
                    TypedValue res = new TypedValue();
                    getContext().getTheme().resolveAttribute(
                            R.attr.dialogTitleDecorLayout, res, true);
                    layoutResource = res.resourceId;
                } else if ((features & (1 << FEATURE_ACTION_BAR)) != 0) {
        
                    layoutResource = a.getResourceId(
                            R.styleable.Window_windowActionBarFullscreenDecorLayout,
                            R.layout.screen_action_bar);
                } else {
        
                    layoutResource = R.layout.screen_title;
                }
                // System.out.println("Title!");
            } else if ((features & (1 << FEATURE_ACTION_MODE_OVERLAY)) != 0) {
        
                layoutResource = R.layout.screen_simple_overlay_action_mode;
            } else {
        
                // Embedded, so no decoration is needed.
                layoutResource = R.layout.screen_simple;
                // System.out.println("Simple!");
            }
    
            mDecor.startChanging();
            mDecor.onResourcesLoaded(mLayoutInflater, layoutResource);//实际上DecorView会根据不同的情况加载不同的布局文件,然后contentParent才从DecorView中去找到主布局
    
    		
            ViewGroup contentParent = (ViewGroup)findViewById(ID_ANDROID_CONTENT);//findViewById方法实际上就是在调用mDecor的findViewById方法,id就是com.android.internal.R.id.content
            if (contentParent == null) {
        
                throw new RuntimeException("Window couldn't find content container view");
            }
    
            //....
    
            return contentParent;
        }

实际上即使我们没有调用setContentView方法,DecorView也会被初始化,具体的位置就在Activity的performCreate方法中

final void performCreate(Bundle icicle, PersistableBundle persistentState) {
        
            mCanEnterPictureInPicture = true;
            restoreHasCurrentPermissionRequest(icicle);
            if (persistentState != null) {
        
                onCreate(icicle, persistentState);
            } else {
        
                onCreate(icicle);
            }
            mActivityTransitionState.readState(icicle);
    
            mVisibleFromClient = !mWindow.getWindowStyle().getBoolean(
                    com.android.internal.R.styleable.Window_windowNoDisplay, false);
            mFragments.dispatchActivityCreated();
            mActivityTransitionState.setEnterActivityOptions(this, getActivityOptions());//注意这里
        }

//这个方法在ActivityTransitionState类中
        public void setEnterActivityOptions(Activity activity, ActivityOptions options) {
        
            final Window window = activity.getWindow();
            if (window == null) {
        
                return;
            }
            // ensure Decor View has been created so that the window features are activated
            window.getDecorView();//在这里会确保DecorView已经被创建
            if (window.hasFeature(Window.FEATURE_ACTIVITY_TRANSITIONS)
                    && options != null && mEnterActivityOptions == null
                    && mEnterTransitionCoordinator == null
                    && options.getAnimationType() == ActivityOptions.ANIM_SCENE_TRANSITION) {
        
                mEnterActivityOptions = options;
                mIsEnterTriggered = false;
                if (mEnterActivityOptions.isReturning()) {
        
                    restoreExitedViews();
                    int result = mEnterActivityOptions.getResultCode();
                    if (result != 0) {
        
                        Intent intent = mEnterActivityOptions.getResultData();
                        if (intent != null) {
        
                            intent.setExtrasClassLoader(activity.getClassLoader());
                        }
                        activity.onActivityReenter(result, intent);
                    }
                }
            }
        }

好了,到这里DecorView算是初始化完成了,布局也设置了,但是DecorView还没有添加到WindowManager中去,我们可以顺着刚刚看的Activity的生命周期继续往下看  
当执行完onCreate和onStart开始执行onResume

final void handleResumeActivity(IBinder token,
                boolean clearHide, boolean isForward, boolean reallyResume, int seq, String reason) {
        
            ActivityClientRecord r = mActivities.get(token);
            if (!checkAndUpdateLifecycleSeq(seq, r, "resumeActivity")) {
        
                return;
            }
    
            // If we are getting ready to gc after going to the background, well
            // we are back active so skip it.
            unscheduleGcIdler();
            mSomeActivitiesChanged = true;
    
            // TODO Push resumeArgs into the activity for consideration
            r = performResumeActivity(token, clearHide, reason);//这里去执行Activity的onResume生命周期
    
            if (r != null) {
        
                final Activity a = r.activity;
    
                if (localLOGV) Slog.v(
                    TAG, "Resume " + r + " started activity: " +
                    a.mStartedActivity + ", hideForNow: " + r.hideForNow
                    + ", finished: " + a.mFinished);
    
                final int forwardBit = isForward ?
                        WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION : 0;
    
                // If the window hasn't yet been added to the window manager,
                // and this guy didn't finish itself or start another activity,
                // then go ahead and add the window.
                boolean willBeVisible = !a.mStartedActivity;
                if (!willBeVisible) {
        
                    try {
        
                        willBeVisible = ActivityManager.getService().willActivityBeVisible(
                                a.getActivityToken());
                    } catch (RemoteException e) {
        
                        throw e.rethrowFromSystemServer();
                    }
                }
                if (r.window == null && !a.mFinished && willBeVisible) {
        
                    r.window = r.activity.getWindow();
                    View decor = r.window.getDecorView();
                    decor.setVisibility(View.INVISIBLE);
                    ViewManager wm = a.getWindowManager();
                    WindowManager.LayoutParams l = r.window.getAttributes();
                    a.mDecor = decor;
                    l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
                    l.softInputMode |= forwardBit;
                    if (r.mPreserveWindow) {
        
                        a.mWindowAdded = true;
                        r.mPreserveWindow = false;
                        // Normally the ViewRoot sets up callbacks with the Activity
                        // in addView->ViewRootImpl#setView. If we are instead reusing
                        // the decor view we have to notify the view root that the
                        // callbacks may have changed.
                        ViewRootImpl impl = decor.getViewRootImpl();
                        if (impl != null) {
        
                            impl.notifyChildRebuilt();
                        }
                    }
                    if (a.mVisibleFromClient) {
        
                        if (!a.mWindowAdded) {
        //Activity.mWindowAdded这个值是用来判断mDecor是否已经添加到WindowManager中
                            a.mWindowAdded = true;//设置为true
                            wm.addView(decor, l);//添加视图
                        } else {
        
                            // The activity will get a callback for this {@link LayoutParams} change
                            // earlier. However, at that time the decor will not be set (this is set
                            // in this method), so no action will be taken. This call ensures the
                            // callback occurs with the decor set.
                            a.onWindowAttributesChanged(l);
                        }
                    }
    
                // If the window has already been added, but during resume
                // we started another activity, then don't yet make the
                // window visible.
                } else if (!willBeVisible) {
        
                    if (localLOGV) Slog.v(
                        TAG, "Launch " + r + " mStartedActivity set");
                    r.hideForNow = true;
                }
    
                // Get rid of anything left hanging around.
                cleanUpPendingRemoveWindows(r, false /* force */);
    
                // The window is now visible if it has been added, we are not
                // simply finishing, and we are not starting another activity.
                if (!r.activity.mFinished && willBeVisible
                        && r.activity.mDecor != null && !r.hideForNow) {
        
                    if (r.newConfig != null) {
        
                        performConfigurationChangedForActivity(r, r.newConfig);
                        if (DEBUG_CONFIGURATION) Slog.v(TAG, "Resuming activity "
                                + r.activityInfo.name + " with newConfig " + r.activity.mCurrentConfig);
                        r.newConfig = null;
                    }
                    if (localLOGV) Slog.v(TAG, "Resuming " + r + " with isForward="
                            + isForward);
                    WindowManager.LayoutParams l = r.window.getAttributes();
                    if ((l.softInputMode
                            & WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION)
                            != forwardBit) {
        
                        l.softInputMode = (l.softInputMode
                                & (~WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION))
                                | forwardBit;
                        if (r.activity.mVisibleFromClient) {
        
                            ViewManager wm = a.getWindowManager();
                            View decor = r.window.getDecorView();
                            wm.updateViewLayout(decor, l);
                        }
                    }
    
                    r.activity.mVisibleFromServer = true;
                    mNumVisibleActivities++;
                    if (r.activity.mVisibleFromClient) {
        
                        r.activity.makeVisible();//onResume生命流程已经执行完成,将WindowManager设置为可见
                    }
                }
    
                if (!r.onlyLocalRequest) {
        
                    r.nextIdle = mNewActivities;
                    mNewActivities = r;
                    if (localLOGV) Slog.v(
                        TAG, "Scheduling idle handler for " + r);
                    Looper.myQueue().addIdleHandler(new Idler());
                }
                r.onlyLocalRequest = false;
    
                // Tell the activity manager we have resumed.
                if (reallyResume) {
        
                    try {
        
                        ActivityManager.getService().activityResumed(token);
                    } catch (RemoteException ex) {
        
                        throw ex.rethrowFromSystemServer();
                    }
                }
    
            } else {
        
                // If an exception was thrown when trying to resume, then
                // just end this activity.
                try {
        
                    ActivityManager.getService()
                        .finishActivity(token, Activity.RESULT_CANCELED, null,
                                Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
                } catch (RemoteException ex) {
        
                    throw ex.rethrowFromSystemServer();
                }
            }
        }

WindowManager也只是一个接口继承自ViewManager,实际的实现类是WindowManagerImpl,至于为什么初始化的是WindowManagerImpl另行说明

继续看下WindowManagerImpl的addView做了哪些事情,

private final WindowManagerGlobal mGlobal = WindowManagerGlobal.getInstance();//单例模式,全局唯一
    	
    	
        @Override
        public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
        
            applyDefaultToken(params);
            mGlobal.addView(view, params, mContext.getDisplay(), mParentWindow);//看得出实际上调用的是WindowManagerGlobal的addView方法
        }

实际上不仅仅是addView,WindowManagerImpl所实现的ViewManager的三个方法,内部都是调用的WindowManagerGlobal的方法 继续查看WindowManagerGlobal的方法

private final ArrayList<View> mViews = new ArrayList<View>();//保存所有window对象的view
        private final ArrayList<ViewRootImpl> mRoots = new ArrayList<ViewRootImpl>();//保存所有window对应的ViewRootImpl
        private final ArrayList<WindowManager.LayoutParams> mParams =
                new ArrayList<WindowManager.LayoutParams>();//保存所有window对应的布局参数
        private final ArraySet<View> mDyingViews = new ArraySet<View>();//保存正在被删除的View对象
    			
    			
        public void addView(View view, ViewGroup.LayoutParams params,
                Display display, Window parentWindow) {
        
            if (view == null) {
        
                throw new IllegalArgumentException("view must not be null");
            }
            if (display == null) {
        
                throw new IllegalArgumentException("display must not be null");
            }
            if (!(params instanceof WindowManager.LayoutParams)) {
        
                throw new IllegalArgumentException("Params must be WindowManager.LayoutParams");
            }
    
            final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams) params;
            if (parentWindow != null) {
        
                parentWindow.adjustLayoutParamsForSubWindow(wparams);
            } else {
        
                // If there's no parent, then hardware acceleration for this view is
                // set from the application's hardware acceleration setting.
                final Context context = view.getContext();
                if (context != null
                        && (context.getApplicationInfo().flags
                                & ApplicationInfo.FLAG_HARDWARE_ACCELERATED) != 0) {
        
                    wparams.flags |= WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED;
                }
            }
    
            ViewRootImpl root;//定义ViewRootImpl
            View panelParentView = null;
    
            synchronized (mLock) {
        
                // Start watching for system property changes.
                if (mSystemPropertyUpdater == null) {
        
                    mSystemPropertyUpdater = new Runnable() {
        
                        @Override public void run() {
        
                            synchronized (mLock) {
        
                                for (int i = mRoots.size() - 1; i >= 0; --i) {
        
                                    mRoots.get(i).loadSystemProperties();
                                }
                            }
                        }
                    };
                    SystemProperties.addChangeCallback(mSystemPropertyUpdater);
                }
    
                int index = findViewLocked(view, false);
                if (index >= 0) {
        
                    if (mDyingViews.contains(view)) {
        
                        // Don't wait for MSG_DIE to make it's way through root's queue.
                        mRoots.get(index).doDie();
                    } else {
        
                        throw new IllegalStateException("View " + view
                                + " has already been added to the window manager.");
                    }
                    // The previous removeView() had not completed executing. Now it has.
                }
    
                // If this is a panel window, then find the window it is being
                // attached to for future reference.
                if (wparams.type >= WindowManager.LayoutParams.FIRST_SUB_WINDOW &&
                        wparams.type <= WindowManager.LayoutParams.LAST_SUB_WINDOW) {
        
                    final int count = mViews.size();
                    for (int i = 0; i < count; i++) {
        
                        if (mRoots.get(i).mWindow.asBinder() == wparams.token) {
        
                            panelParentView = mViews.get(i);
                        }
                    }
                }
    
                root = new ViewRootImpl(view.getContext(), display);//初始化ViewRootImpl
    
                view.setLayoutParams(wparams);//设置布局参数
    
                mViews.add(view);//存储相应内容
                mRoots.add(root);
                mParams.add(wparams);
    
                // do this last because it fires off messages to start doing things
                try {
        
                    root.setView(view, wparams, panelParentView);//给ViewRootImpl设置view,此时就会开始view的三大流程,以及window的添加操作
                } catch (RuntimeException e) {
        
                    // BadTokenException or InvalidDisplayException, clean up.
                    if (index >= 0) {
        
                        removeViewLocked(index, true);
                    }
                    throw e;
                }
            }
        }

至此,Activity的创建到显示的全部流程就已讲述完毕,包括Activity的部分生命周期,setContentView方法源码,DecorView的创建,window等,我从对这些概念云里雾,到现在对这些东西有了一定程度的认知,确实花费了不少的功夫.

仅仅看一些相关的博客文章会看的云里雾里,但是结合代码和博客一起看就会有一种：哦~原来是这这个东西啊. 的这种感觉,哈哈哈哈.本文侧重流程没有忽视了很多代码细节,有兴趣的可以自行研究

原来我的本意就是去看下View的工作原理而已…

有误的地方欢迎指正