前言

这段时间，leader安排的任务进行Android插件化，热修复相关的调研，对于插件化和热修复涉及到的核心技术点，在于对于类装载，资源装载的认识还有对于启动流程的熟悉，带着该任务，于是有了接下来，一系列的文章，从进程启动，Activity显示，Dex装载，资源装载，最后主流几个插件化，热修复源码实现的分析。本篇先从进程的启动，到一个Activity的显示流程出发分析。

启动一个进程

在Anroid中，进程是一个运行组件的容器，系统运行一个组件的时候，启动包含它的进程，当组件不再使用，进程会被关闭。AMS负责对应应用进程的启动。

开启一个新的进程，在AMS中首先调用addAppLocked

final ProcessRecord addAppLocked(ApplicationInfo info, boolean isolated,        String abiOverride) {    ProcessRecord app;    if (!isolated) {        //从已经开启记录下的进程中查找进程记录        app = getProcessRecordLocked(info.processName, info.uid, true);    } else {        app = null;    }    //app为空的时候，创建一个新的进程，同时更新内部进程管理结构    if (app == null) {        app = newProcessRecordLocked(info, null, isolated, 0);        updateLruProcessLocked(app, false, null);        updateOomAdjLocked();    }    .....    if ((info.flags & PERSISTENT_MASK) == PERSISTENT_MASK) {        app.persistent = true;        app.maxAdj = ProcessList.PERSISTENT_PROC_ADJ;    }    if (app.thread == null && mPersistentStartingProcesses.indexOf(app) < 0) {        mPersistentStartingProcesses.add(app);      //调用进程的启动方法，启动一个新的进程        startProcessLocked(app, "added application", app.processName, abiOverride,                null /* entryPoint */, null /* entryPointArgs */);    }    return app;}复制代码

首先会从已经启动的进程中查找相应的进程信息，ProcessRecord，如果不存在则会创建一个出来，然后调用startProcessLocked方法，来开启一个新的进程。

private final void startProcessLocked(ProcessRecord app, String hostingType,        String hostingNameStr, String abiOverride, String entryPoint, String[] entryPointArgs) {    //启动应用    ....    Process.ProcessStartResult startResult = Process.start(entryPoint,            app.processName, uid, uid, gids, debugFlags, mountExternal,            app.info.targetSdkVersion, app.info.seinfo, requiredAbi, instructionSet,            app.info.dataDir, entryPointArgs);      ....  //发送定时消息，如果App的启动超时，则会ANR    synchronized (mPidsSelfLocked) {        this.mPidsSelfLocked.put(startResult.pid, app);        if (isActivityProcess) {            Message msg = mHandler.obtainMessage(PROC_START_TIMEOUT_MSG);            msg.obj = app;            mHandler.sendMessageDelayed(msg, startResult.usingWrapper                    ? PROC_START_TIMEOUT_WITH_WRAPPER : PROC_START_TIMEOUT);        }    }    ....}复制代码

进程的开启调用的是Process的start方法。

public static final ProcessStartResult start(final String processClass,                              final String niceName,                              int uid, int gid, int[] gids,                              int debugFlags, int mountExternal,                              int targetSdkVersion,                              String seInfo,                              String abi,                              String instructionSet,                              String appDataDir,                              String[] zygoteArgs) {    try {        return startViaZygote(processClass, niceName, uid, gid, gids,                debugFlags, mountExternal, targetSdkVersion, seInfo,                abi, instructionSet, appDataDir, zygoteArgs);    } catch (ZygoteStartFailedEx ex) {          }}复制代码

start方法中，通过调用startViaZygote，通过zygote进程来开启一个新的进程。

private static ProcessStartResult startViaZygote(final String processClass, ...){    //配置通过Zygote启动的参数，最终通过socket写入到Zygote进程，来开启一个新的进程}复制代码

方法的具体执行是通过socket将进程的启动信息，写入到zygote中，然后通过其启动一个新的进程，同时对于该进程，也指定了一个类作为执行的入口类，这个类就是ActivityThread。

entryPoint = "android.app.ActivityThread";复制代码

在start方法中的entryPoint，这个就是进程启动后要执行的Java类，进程启动后，所有操作就转交到ActivityThread的执行，因此，这个类也是整个应用执行的核心。这个类首先被执行的是其main函数。

public static void main(String[] args) {      ...      Looper.prepareMainLooper();     ActivityThread thread = new ActivityThread();    thread.attach(false);     Looper.loop();    ....}复制代码

ActivityThread的attach方法。

private void attach(boolean system) {      ......final IActivityManager mgr = ActivityManagerNative.getDefault();    try {        //调用AMS的attachApplication方法，传递ApplicationThread进去        mgr.attachApplication(mAppThread);    } catch (RemoteException ex) {        throw ex.rethrowFromSystemServer();    }      .....}复制代码

Ams的attachApplication方法会调用到Ams的attachApplicationLocked方法，

thread.bindApplication(processName, appInfo, providers, app.instrumentationClass,...)复制代码

这个方法的主要功能是创建出应用程序中的各种对象，是比较核心的方法。

private void handleBindApplication(AppBindData data) {    // 注册当前UI线程到Runtime作为一个敏感线程    VMRuntime.registerSensitiveThread();    // 设置进程的启动时间    Process.setStartTimes(SystemClock.elapsedRealtime(), SystemClock.uptimeMillis());    // 创建进程的配置对象    mBoundApplication = data;    mConfiguration = new Configuration(data.config);    mCompatConfiguration = new Configuration(data.config);    //当版本低于Honeycomb MR1，将AsyncTask的实现通过使用线程池    if (data.appInfo.targetSdkVersion <= android.os.Build.VERSION_CODES.HONEYCOMB_MR1) {        AsyncTask.setDefaultExecutor(AsyncTask.THREAD_POOL_EXECUTOR);    }    //设置应用的时区和应用的地区    TimeZone.setDefault(null);    LocaleList.setDefault(data.config.getLocales());    synchronized (mResourcesManager) {        mResourcesManager.applyConfigurationToResourcesLocked(data.config, data.compatInfo);        mCurDefaultDisplayDpi = data.config.densityDpi;        applyCompatConfiguration(mCurDefaultDisplayDpi);    }    // 创建Instrumentation    final InstrumentationInfo ii;    if (data.instrumentationName != null) {        try {            ii = new ApplicationPackageManager(null, getPackageManager())                    .getInstrumentationInfo(data.instrumentationName, 0);        } catch (PackageManager.NameNotFoundException e) {            throw new RuntimeException(                    "Unable to find instrumentation info for: " + data.instrumentationName);        }        mInstrumentationPackageName = ii.packageName;        mInstrumentationAppDir = ii.sourceDir;        mInstrumentationSplitAppDirs = ii.splitSourceDirs;        mInstrumentationLibDir = getInstrumentationLibrary(data.appInfo, ii);        mInstrumentedAppDir = data.info.getAppDir();        mInstrumentedSplitAppDirs = data.info.getSplitAppDirs();        mInstrumentedLibDir = data.info.getLibDir();    } else {        ii = null;    }    final ContextImpl appContext = ContextImpl.createAppContext(this, data.info);    updateLocaleListFromAppContext(appContext,            mResourcesManager.getConfiguration().getLocales());    // Continue loading instrumentation.    if (ii != null) {        final ApplicationInfo instrApp = new ApplicationInfo();        ii.copyTo(instrApp);        instrApp.initForUser(UserHandle.myUserId());        final LoadedApk pi = getPackageInfo(instrApp, data.compatInfo,                appContext.getClassLoader(), false, true, false);        final ContextImpl instrContext = ContextImpl.createAppContext(this, pi);        //        try {            final ClassLoader cl = instrContext.getClassLoader();            mInstrumentation = (Instrumentation)                cl.loadClass(data.instrumentationName.getClassName()).newInstance();        } catch (Exception e) {            throw new RuntimeException(                "Unable to instantiate instrumentation "                + data.instrumentationName + ": " + e.toString(), e);        }        final ComponentName component = new ComponentName(ii.packageName, ii.name);        mInstrumentation.init(this, instrContext, appContext, component,                data.instrumentationWatcher, data.instrumentationUiAutomationConnection);        if (mProfiler.profileFile != null && !ii.handleProfiling                && mProfiler.profileFd == null) {            mProfiler.handlingProfiling = true;            final File file = new File(mProfiler.profileFile);            file.getParentFile().mkdirs();            Debug.startMethodTracing(file.toString(), 8 * 1024 * 1024);        }    } else {        mInstrumentation = new Instrumentation();    }    //Application中指定了big heap，清除限制    if ((data.appInfo.flags&ApplicationInfo.FLAG_LARGE_HEAP) != 0) {        dalvik.system.VMRuntime.getRuntime().clearGrowthLimit();    } else {        dalvik.system.VMRuntime.getRuntime().clampGrowthLimit();    }    final StrictMode.ThreadPolicy savedPolicy = StrictMode.allowThreadDiskWrites();    try {        //生成Application对象        Application app = data.info.makeApplication(data.restrictedBackupMode, null);        mInitialApplication = app;            .....        try {            //调用Instrumentation的onCreate方法            mInstrumentation.onCreate(data.instrumentationArgs);        }        catch (Exception e) {                    }        try {            //调用Application的onCreate方法            mInstrumentation.callApplicationOnCreate(app);        } catch (Exception e) {                   }    } finally {        StrictMode.setThreadPolicy(savedPolicy);    }}复制代码

至此一个应用进程被打开，同时其Instrumentation和Application的onCreate方法也被调用了，接下来就是Activity的执行。

Activity启动到显示

从上面的进程启动可以得知每一个进程对应一个Application，对应一个ActivityThread，也对应这一个Instrumentation。对于Activity的启动会调用到其handleLaunchActivity方法。

handleLaunchActivity

private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {		....     WindowManagerGlobal.initialize();     Activity a = performLaunchActivity(r, customIntent);     if (a != null) {     	handleResumeActivity(r.token, false, r.isForward,                    !r.activity.mFinished && !r.startsNotResumed, 			r.lastProcessedSeq, reason);                    ...     } else {        ActivityManagerNative.getDefault()                    .finishActivity(r.token, Activity.RESULT_CANCELED, null,                            Activity.DONT_FINISH_TASK_WITH_ACTIVITY);    }}复制代码

该方法首先对WindowManagerGlobal做了初始化操作，然后调用了performLaunchActivity方法，返回一个Activity对象后，返回对象伪非空，则调用handleResumeActivity。如果为空调用ActivityManager的finishActivity方法。对于启动，这里performLaunchActivity和handleResumeActivity两个方法是核心。接下来将针对这两个方法来进行分析。

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {   //获取该Activity的包信息，这里为LoadedApk类型   ActivityInfo aInfo = r.activityInfo;   if (r.packageInfo == null) {       r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,                    Context.CONTEXT_INCLUDE_CODE);   }		...      //创建Activity实例	java.lang.ClassLoader cl = r.packageInfo.getClassLoader();    activity = mInstrumentation.newActivity(        cl, component.getClassName(), r.intent);    //获取Application实例    Application app = r.packageInfo.makeApplication(false, mInstrumentation);   //创建窗口实例，并调用activity的attch方法，attach该窗口        Window window = null;    if (r.mPendingRemoveWindow != null && r.mPreserveWindow) {       window = r.mPendingRemoveWindow;       r.mPendingRemoveWindow = null;       r.mPendingRemoveWindowManager = null;     }     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);                    ....     //为Activity设置主题    int theme = r.activityInfo.getThemeResource();    if (theme != 0) {         activity.setTheme(theme);     }     ....   //调用该Activity的onCreate方法    mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);    ....    mActivities.put(r.token, r);    ...}复制代码

首先根据Activity的信息来获取相关的包信息，这里调用了getPackInfo来获得相关的包信息。得到一个LoadedApk类型来表示当前的Activity的包信息。

public final LoadedApk getPackageInfo(String packageName, CompatibilityInfo compatInfo,            int flags) {    return getPackageInfo(packageName, compatInfo, flags, UserHandle.myUserId());}复制代码

其中包含了Activity相关的信息Application信息，资源目录等等。在获得了LoadedApk实例之后，调用其makApplication方法，我们会疑问，在启动一个Activity的时候，难道每次都要创建一个Application对象吗？跟进源码。

public Application makeApplication(boolean forceDefaultAppClass,            Instrumentation instrumentation) {  if (mApplication != null) {      return mApplication;  }    .... //创建Application实例  java.lang.ClassLoader cl = getClassLoader();  if (!mPackageName.equals("android")) {       initializeJavaContextClassLoader();   }   ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);   app = mActivityThread.mInstrumentation.newApplication(                    cl, appClass, appContext);   appContext.setOuterContext(app);   mActivityThread.mAllApplications.add(app);   mApplication = app;    //调用Application的onCreate方法   instrumentation.callApplicationOnCreate(app);}复制代码

通过makeApplication的方法实现，我们可以看到其首先判断Application对象是否创建，如果没有创建，则初始化类装载器，然后创建Application对象，创建完成，则调用Application对象的onCreate方法。这里也就是我们所熟知的在我们自定义Application的时候重写的onCreate方法将会被调用。 继续回到上面代码的分析，这里的Activity通过类装载器被装载出来，然后实例化出一个对象，然后调用了其attach方法，进行了一系列信息的配置。然后调用了mInstrumentation，调用了callActivityOnCreate。同时也会将我们的Activity添加到mActivitys中，这里其定义如下。

final ArrayMap
    
      mActivities = new ArrayMap<>();复制代码
    

通过这段代码可以看到，调用了acticity的attach方法，跟进attach方法。

final void attach(Context context, ....,Window window) {     mWindow = new PhoneWindow(this, window);     mWindow.setWindowControllerCallback(this);     mWindow.setCallback(this);     mWindow.setOnWindowDismissedCallback(this);               .....     mWindow.setWindowManager(                    (WindowManager)context.getSystemService(Context.WINDOW_SERVICE),          .....);       .....    mWindowManager = mWindow.getWindowManager();}复制代码

至此，我们Activity中的Window已经被创建出来了。Window实际类型为PhoneWindow。同时为该Window设置了WindowManager。至此，我们虽然不了解Window是个什么东西，但是至少，我们可以知道的一点就是每一个Activity的创建是会有持有一个Window对象的。然后Instrumentation的callActivityOnCreate方法被调用。

callActivityOnCreate

public void callActivityOnCreate(Activity activity, Bundle icicle) {    prePerformCreate(activity);    activity.performCreate(icicle);    postPerformCreate(activity);}复制代码

这里对于Activity的具体启动细节，我们不做关心，具体细节，接下来的源码分析会做介绍，这里先看一下Activity的performCreate方法。

final void performCreate(Bundle icicle) {   restoreHasCurrentPermissionRequest(icicle);   onCreate(icicle);   mActivityTransitionState.readState(icicle);   performCreateCommon();}复制代码

这个时候调用了Activity的performCreate函数，调用了Activity的onCreate，我们一般会在onCreate中调用setContentView，进行我们布局文件的设置。这也是比较奇怪的一点，为什么，我们调用了该方法，传递一个xml布局文件，我们的View就显示出来了呢？这便是这次代码分析的核心，所有围绕的相关知识点也会在此被引出。接下来，让我们剥茧抽丝，逐层递进。

public void setContentView(@LayoutRes int layoutResID) {    getWindow().setContentView(layoutResID);    initWindowDecorActionBar();}复制代码

此处的Window即为在attach中得到的PhoneWindow的实例。

public void setContentView(int layoutResID) {	if (mContentParent  ==  null) {          installDecor();       } 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是用来放置contentView的，如果不为空则要清理掉所有的view，如果为null，调用installDecor()，其中，我们可以看到有调用对于transitions这个feature的判断，这个是在Android系统5.0之后添加的一个功能，可以用来实现Activity的过渡，同时还是实现Activity之间的元素共享，使得Activity间切换更加的丝滑流畅。这里对于该场景不做分析，我们跳过看其具体的View装载，然后调用了

mLayoutInflater.inflate(layoutResID, mContentParent);

private void installDecor() {	mDecor = generateDecor(-1);	....    mContentParent = generateLayout(mDecor);	...     //过渡动画，标题，logo，UI选项的显示处理}复制代码

在installDecor中，首先调用了generateDecor方法，然后根据创建的DecorView，来生成ContentView。

protected DecorView generateDecor(int featureId) {    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());    }复制代码

根据是否使用DecorContext来创建相应的context，然后利用该Context来创建DecorView。那么这个DecorView到底是个什么呢？

public class DecorView extends FrameLayout复制代码

DecorView其实就是一个FrameLayout。这个FrameLayout则是我们所看到的Activity试图的根View，在创建了一个DecorView之后，又根据这个DecorView实例来创建了ContentView。

这里创建的DecorView其实是一个FrameLayout,

由上面函数可以看出，mContentParent是和mDecor有关的，下面来看一下ContentParent的创建过程。

protected ViewGroup generateLayout(DecorView decor) {...	//根据样式，选择相应的资源文件，进行相应的资源装载	mDecor.startChanging();    mDecor.onResourcesLoaded(mLayoutInflater, layoutResource);	ViewGroup contentParent = (ViewGroup)findViewById(ID_ANDROID_CONTENT);	...        return contentParent;}复制代码

开始之前调用了DecorView的onResourcesLoaded，然后通过findViewById的方式，返回一个VieGroup作为contentParent。这里的findViewById的实现在基类Window中。

public View findViewById(@IdRes int id) {   return getDecorView().findViewById(id);}复制代码

onResourcesLoaded的方法如下。

void onResourcesLoaded(LayoutInflater inflater, int layoutResource) {    ....    mDecorCaptionView = createDecorCaptionView(inflater);    final View root = inflater.inflate(layoutResource, null);    if (mDecorCaptionView != null) {         if (mDecorCaptionView.getParent() == null) {             addView(mDecorCaptionView,                        new ViewGroup.LayoutParams(MATCH_PARENT, MATCH_PARENT));         }         mDecorCaptionView.addView(root,                    new ViewGroup.MarginLayoutParams(MATCH_PARENT, MATCH_PARENT));        } else {          addView(root, 0, new ViewGroup.LayoutParams(MATCH_PARENT, MATCH_PARENT));        }    mContentRoot = (ViewGroup) root;    initializeElevation();}复制代码

根据相应的UI样式配置，选择合适的布局资源文件，然后通过inflate装载相应的资源文件，创建ContentView，同时将其添加到DecorView中。 在创建了DecorView和ContentParent之后，接下来，则利用了我们传递的xml布局文件id。

mLayoutInflater.inflate(layoutResID, mContentParent);复制代码

LayoutInflater中inflate的实现如下

public View inflate(@LayoutRes int resource, @Nullable ViewGroup root) {     return inflate(resource, root, root != null);}复制代码

public View inflate(@LayoutRes int resource, @Nullable ViewGroup root, boolean attachToRoot) {    final Resources res = getContext().getResources();           final XmlResourceParser parser = res.getLayout(resource);    try {        return inflate(parser, root, attachToRoot);    } finally {        parser.close();    }}复制代码

public View inflate(XmlPullParser parser, @Nullable ViewGroup root, boolean attachToRoot) {   ....   final View temp = createViewFromTag(root, name, inflaterContext, attrs);   ....   if (root != null && attachToRoot) {      root.addView(temp, params);   }   ...}复制代码

根据我们的布局文件ID，创建出一个View，然后将该View添加到我们的contentView之中。在setContentView中，当我们结束了instalDecor方法之后，会调用initWindowDecorActionBar来进行ActionBar的初始化操作，创建ActionBar。

private void initWindowDecorActionBar() {     Window window = getWindow();     window.getDecorView();     if (isChild() || !window.hasFeature(Window.FEATURE_ACTION_BAR) || mActionBar != null) {         return;     }    mActionBar = new WindowDecorActionBar(this);    mActionBar.setDefaultDisplayHomeAsUpEnabled(mEnableDefaultActionBarUp);    mWindow.setDefaultIcon(mActivityInfo.getIconResource());    mWindow.setDefaultLogo(mActivityInfo.getLogoResource());}复制代码

handleResumeActivity

通过performLaunchActivity，我们已经装载出了资源，同时创建了DecorView和contentParentView，同时也完成了Window的创建，同时也将我们设置的资源文件，装载出来成为了View。但是我们知道一个Activity可见时，我们的onResume方法是被调用的了，在performLaunchActivity被调用之后又调用了handleResumeActivity()。

final void handleResumeActivity(IBinder token,            boolean clearHide, ....) {   ActivityClientRecord r = mActivities.get(token);	...   r = performResumeActivity(token, clearHide, reason);   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;         ViewRootImpl impl = decor.getViewRootImpl();         if (impl != null) {             impl.notifyChildRebuilt();         }      }      if (a.mVisibleFromClient && !a.mWindowAdded) {         a.mWindowAdded = true;         wm.addView(decor, l);      }}复制代码

该方法首先调用了performResumeActivity函数。performResumeActivity中进行了大量的状态相关的判断，而对于首次启动的分析，我们所关心的核心就是其调用了Activity的performResume，也就是Activity的onResume函数被调用了。

public final ActivityClientRecord performResumeActivity(IBinder token,boolean clearHide, String reason) {    ...    r.activity.performResume();    ...}复制代码

最开始调用了Activity的Resume 函数，然后进行了后续的调用。这里看到一个ViewRootImpl中，通过decor调用getViewRootImpl()来获得

public ViewRootImpl getViewRootImpl() {   if (mAttachInfo != null)  {      return mAttachInfo.mViewRootImpl;   }    return null;}复制代码

该方法中核心代码为

wm.addView(decor, l);复制代码

调用了WindowManager的addView方法，来添加当前的DecorView。

@Override    public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {        applyDefaultToken(params);        mGlobal.addView(view, params, mContext.getDisplay(), mParentWindow);    }复制代码

public void addView(View view, ViewGroup.LayoutParams params,            Display display, Window parentWindow) {     ....    ViewRootImpl root;    View panelParentView = null;     ....     root = new ViewRootImpl(view.getContext(), display);     view.setLayoutParams(wparams);      ....      mViews.add(view);      mRoots.add(root);      mParams.add(wparams);      ....       // do this last because it fires off messages to start doing things     root.setView(view, wparams, panelParentView);}复制代码

在WindowManager中的addView调用了WindowManagerGlobal的addView方法，在最开始的时候，我们调用过

WindowManagerGlobal.initialize();复制代码

WindowManagerGlobal是个单例类，其保证了对于整个应用层，只具备一个WindowManagerService。同时其具备三个ArryList，分别保存一个应用的根View，ViewRootImpl和LayoutParams，该方法，创建了一个ViewRootImpl实例，然后将View，ViewRoot，LayoutParams添加到相应的ArrayList中，最后调用ViewRoot的setView方法。这里的setView方法会将其设置为自身的View，以后的绘制等事件都交给ViewRootImpl来实现。绘制涉及到布局，测量，绘制三个环节，具体的过程此处不再展开，本篇主要目的是为了接下来的插件化和热修复做一个基础。

总结

至此，我们已经知道了从一个Activity的启动到我们的View逐步被创建的过程，但是这里并没有涉及到绘制相关的内容，那么这个View最终如何绘制出来的呢？接下来，我们首先从ViewRootImpl来切入做分析，逐步理清楚接下来做的事情。