Android Activity——启动过程探索（一）

概述Activity生命周期：首先来看一下当Activity启动时，会回调哪些生命周期的方法：不关闭当前Activity启动流程：关闭当前Activity启动流程：对于上面的回调过程，我想大部分Android开发者都是知道的，但是对于系统是怎样一步一步来回调这些方法的，可能存在不少疑问。下面我们就通过源

Activity 生命周期：

首先来看一下当Activity启动时，会回调哪些生命周期的方法：

不关闭当前Activity启动流程：

关闭当前Activity启动流程：

对于上面的回调过程，我想大部分AndroID开发者都是知道的，但是对于系统是怎样一步一步来回调这些方法的，可能存在不少疑问。下面我们就通过源码来看看当我们调用 startActivity() 和 finish() 方法时系统是怎样一步步来回调各个方法的。

其实对于每一个生命周期方法的调用，都可以看做是一小步，所以我们的分析就可以比较简单的进行分步：

当前Activity调用 onPause()新的Activity调用 onCreate()新的Activity调用 onStart()新的Activity调用 onResume()当前Activity调用 onStop()当前Activity调用 onDestory()【前提是调用了 finish() 方法】

在实际中，除了以上的生命周期方法回调外，还有一些回调方法也是比较重要的（比如：attach()、onRestart()等），就不在单独分析，而是在对应的地方一起分析了。

注意：以下分析过程，源码版本为 AndroID 10（API 29），不同AndroID版本可能有一些差别。当前Activity调用 onPause() 过程

根据上图查看对应的方法：

当我们调用 startActivity() 之后，系统按如下步骤执行:

-> Activity#startActivity()
-> Activity#startActivityForResult()
-> Instrumentation#execStartActivity(activity, mMainThread.getApplicationThread(), mToken, this,intent, requestCode, options)

说明：

mMainThread.getApplicationThread() 返回 ApplicationThreadApplicationThread 的声明为 ActivityThread.ApplicationThread extends IApplicationThread.Stub

-> ActivityTaskManagerService#startActivity()

说明：

ActivityTaskManagerService 通过 ActivityTaskManager.getService() 获取ActivityTaskManager.getService() 返回 IActivityTaskManagerActivityTaskManagerService 的声明为 ActivityTaskManagerService extends IActivityTaskManager.Stub，所以上一步是： ActivityTaskManagerService#startActivity()

-> ActivityTaskManagerService#startActivityAsUser()

说明：

会多次调用重载方法，这里就看做一步了，最终走到 下一步

-> ActivityStartController#obtainStarter()

说明：

ActivityStartController 通过 getActivityStartController() 方法获取ActivityStartController.obtainStarter() 方法返回的是ActivityStarter对象然后设置数据，实际调用的都是 ActivityStarter 中的设置数据方法，最终调用 ActivityStarter 的 execute() 方法

具体代码如下：

	getActivityStartController().obtainStarter(intent, "startActivityAsUser")                .setCaller(caller)                .setCallingPackage(callingPackage)                .setResolvedType(resolvedType)                .setResultTo(resultTo)                .setResultWho(resultWho)                .setRequestCode(requestCode)                .setStartFlags(startFlags)                .setProfilerInfo(profilerInfo)                .setActivityOptions(bOptions)                .setMayWait(userID) // 注意该方法，会将ActivityStarter mRequest.mayWait = true;                .execute();

-> ActivityStarter#execute()

说明：

上一步的 setMayWait() 方法 会将 ActivityStarter 中的 mRequest.mayWait 标识置为 true，在 execute() 方法中会通过该标记判断下一步执行的方法

-> ActivityStarter#startActivityMayWait()
-> ActivityStarter#startActivity()

说明：

会多次调用重载 startActivity() 方法，这里就看做一步了，最终走到 下一步

-> ActivityStarter#startActivityUnchecked()
-> RootActivityContainer#resumeFocusedStackstopActivitIEs()

说明：

调用重载无参数方法，由无参数方法调用有参数方法，参数都为null，看做一步，走到下一步

-> ActivityStack#resumetopActivityUncheckedLocked()
-> ActivityStack#resumetopActivityInnerLocked()
-> ActivityStack#startPausingLocked()

startPausingLocked() 方法中有如下代码：

mService.getlifecycleManager().scheduleTransaction(prev.app.getThread(),                    prev.appToken, PauseActivityItem.obtain(prev.finishing, userLeaving,                            prev.configChangeFlags, pauseImmediately));

说明：

mService.getlifecycleManager() 方法返回的对象是 ClIEntlifecycleManager，（其中mService 是 ActivityTaskManagerService）重点注意方法中的几个参数： 第一个参数 prev.app.getThread() 获取到的是 IApplicationThread（IApplicationThread 的声明在上面已经说明了）第三个参数 PauseActivityItem.obtain()，注意PauseActivityItem类： PauseActivityItem extends ActivitylifecycleItem

-> ClIEntlifecycleManager#scheduleTransaction(IApplicationThread clIEnt, IBinder activityToken,ActivitylifecycleItem stateRequest)

注意 scheduleTransaction() 方法的代码：

final ClIEntTransaction clIEntTransaction = transactionWithState(clIEnt, activityToken,stateRequest);scheduleTransaction(clIEntTransaction);

构建了一个 ClIEntTransaction 对象 clIEntTransaction 进行传递

-> ClIEntlifecycleManager#scheduleTransaction(ClIEntTransaction transaction)
-> ClIEntTransaction#schedule()
-> IApplicationThread#scheduleTransaction()

说明：

IApplicationThread就是ActivityThread.ApplicationThread在 ActivityThread.ApplicationThread 中直接调用了 ActivityThread.this.scheduleTransaction(transaction)，所以最终调用的是 ActivityThread#scheduleTransaction()，但是 ActivityThread 中并没有这个方法，是在其父类 ClIEntTransactionHandler 中的方法（ ActivityThread extends ClIEntTransactionHandler）

-> ClIEntTransactionHandler#sendMessage()

说明：

sendMessage() 方法在 ClIEntTransactionHandler中定义，由子类 ActivityThread 实现

在sendMessage()方法中传递的 what 是 ActivityThread.H.EXECUTE_TRANSACTION

在ActivityThread中的handler消息都是由 ActivityThread 内部类 H 负责处理，所以查看 H 类中 handleMessage() 方法对应的处理逻辑

 case EXECUTE_TRANSACTION:     final ClIEntTransaction transaction = (ClIEntTransaction) msg.obj;     mTransactionExecutor.execute(transaction);     if (isSystem()) {         transaction.recycle();     }     break;

mTransactionExecutor 对象是 TransactionExecutor

-> TransactionExecutor#execute(transaction)

说明：

参数 transaction 就是上面构建的 ClIEntTransaction 对象

-> TransactionExecutor#executelifecycleState(transaction)

final ActivitylifecycleItem lifecycleItem = transaction.getlifecycleStateRequest();lifecycleItem.execute(mTransactionHandler, token, mPendingActions);

说明：

transaction.getlifecycleStateRequest() 获取到 ActivitylifecycleItem 对象，在这里实际上获取到的就是 PauseActivityItem 对象，上面我们在 ActivityStack#startPausingLocked() 中已经说到了

-> PauseActivityItem#execute()
-> ClIEntTransactionHandler#handlePauseActivity()

说明：

handlePauseActivity() 方法在 ClIEntTransactionHandler中定义，由子类 ActivityThread 实现，所以查看 ActivityThread 的 handlePauseActivity()

-> ActivityThread#performPauseActivity()
-> ActivityThread#performPauseActivityIfNeeded()
-> Instrumentation#callActivityOnPause()
-> Activity#performPause()
-> Activity#onPause()

通过以上过程，最终调用了Activity 的 onPause() 回调方法，到此为止，我们启动Activity的第一步，当前Activity的onPause()回调执行过程就完成了。接下来，查看第二步创建新的Activity实例，并执行 onCreate() 回调。

新的Activity调用 onCreate()

根据上图查看对应的方法：

当我们调用 startActivity() 之后，系统按如下步骤执行:

-> Activity#startActivity()
-> Activity#startActivityForResult()
-> Instrumentation#execStartActivity(activity, mMainThread.getApplicationThread(), mToken, this,intent, requestCode, options)

说明：

mMainThread.getApplicationThread() 返回 ApplicationThreadApplicationThread 的声明为 ActivityThread.ApplicationThread extends IApplicationThread.Stub

-> ActivityTaskManagerService#startActivity()

说明：

ActivityTaskManagerService 通过 ActivityTaskManager.getService() 获取ActivityTaskManager.getService() 返回 IActivityTaskManagerActivityTaskManagerService 的声明为 ActivityTaskManagerService extends IActivityTaskManager.Stub，所以上一步是： ActivityTaskManagerService#startActivity()

-> ActivityTaskManagerService#startActivityAsUser()

说明：

会多次调用重载方法，这里就看做一步了，最终走到 下一步

-> ActivityStartController#obtainStarter()

说明：

ActivityStartController 通过 getActivityStartController() 方法获取ActivityStartController.obtainStarter() 方法返回的是ActivityStarter对象然后设置数据，实际调用的都是 ActivityStarter 中的设置数据方法，最终调用 ActivityStarter 的 execute() 方法

具体代码如下：

	getActivityStartController().obtainStarter(intent, "startActivityAsUser")                .setCaller(caller)                .setCallingPackage(callingPackage)                .setResolvedType(resolvedType)                .setResultTo(resultTo)                .setResultWho(resultWho)                .setRequestCode(requestCode)                .setStartFlags(startFlags)                .setProfilerInfo(profilerInfo)                .setActivityOptions(bOptions)                .setMayWait(userID) // 注意该方法，会将ActivityStarter mRequest.mayWait = true;                .execute();

-> ActivityStarter#execute()

说明：

上一步的 setMayWait() 方法 会将 ActivityStarter 中的 mRequest.mayWait 标识置为 true，在 execute() 方法中会通过该标记判断下一步执行的方法

-> ActivityStarter#startActivityMayWait()
-> ActivityStarter#startActivity()

说明：

会多次调用重载 startActivity() 方法，这里就看做一步了，最终走到 下一步

-> ActivityStarter#startActivityUnchecked()
-> RootActivityContainer#resumeFocusedStackstopActivitIEs()

说明：

调用重载无参数方法，由无参数方法调用有参数方法，参数都为null，看做一步，走到下一步

-> ActivityStack#resumetopActivityUncheckedLocked()
-> ActivityStack#resumetopActivityInnerLocked()
-> ActivityStackSupervisor#startSpecificActivityLocked()
-> ActivityStackSupervisor#realStartActivityLocked()

realStartActivityLocked() 方法中有如下代码：

// Create activity launch transaction.final ClIEntTransaction clIEntTransaction = ClIEntTransaction.obtain(        proc.getThread(), r.appToken);final displayContent dc = r.getdisplay().mdisplayContent;clIEntTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),        System.IDentityHashCode(r), r.info,        mergedConfiguration.getGlobalConfiguration(),        mergedConfiguration.getoverrIDeConfiguration(), r.compat,        r.launchedFromPackage, task.voiceInteractor, proc.getReportedProcState(),        r.icicle, r.persistentState, results, newIntents,        dc.isNextTransitionForward(), proc.createProfilerInfoIfNeeded(),r.assistToken));mService.getlifecycleManager().scheduleTransaction(clIEntTransaction);

说明：

mService.getlifecycleManager() 方法返回的对象是 ClIEntlifecycleManager，（其中mService 是 ActivityTaskManagerService）创建 ClIEntTransaction 对象后，调用了它的 addCallback() 方法，增加了 LaunchActivityItem 对象（LaunchActivityItem extends ClIEntTransactionItem）

-> ClIEntlifecycleManager#scheduleTransaction(ClIEntTransaction transaction)
-> ClIEntTransaction#schedule()
-> IApplicationThread#scheduleTransaction()

说明：

IApplicationThread就是ActivityThread.ApplicationThread在 ActivityThread.ApplicationThread 中直接调用了 ActivityThread.this.scheduleTransaction(transaction)，所以最终调用的是 ActivityThread#scheduleTransaction()，但是 ActivityThread 中并没有这个方法，是在其父类 ClIEntTransactionHandler 中的方法（ ActivityThread extends ClIEntTransactionHandler）

-> ClIEntTransactionHandler#sendMessage()

说明：

sendMessage() 方法在 ClIEntTransactionHandler中定义，由子类 ActivityThread 实现

在sendMessage()方法中传递的 what 是 ActivityThread.H.EXECUTE_TRANSACTION

在ActivityThread中的handler消息都是由 ActivityThread 内部类 H 负责处理，所以查看 H 类中 handleMessage() 方法对应的处理逻辑

 case EXECUTE_TRANSACTION:     final ClIEntTransaction transaction = (ClIEntTransaction) msg.obj;     mTransactionExecutor.execute(transaction);     if (isSystem()) {         transaction.recycle();     }     break;

mTransactionExecutor 对象是 TransactionExecutor

-> TransactionExecutor#execute(transaction)

说明：

参数 transaction 就是上面 realStartActivityLocked() 方法中传递的对象

-> TransactionExecutor#executeCallbacks(transaction)

final ClIEntTransactionItem item = callbacks.get(i);item.execute(mTransactionHandler, token, mPendingActions);

说明：

callbacks.get(i) 获取到 ClIEntTransactionItem 对象，在这里实际上获取到的就是 LaunchActivityItem 对象，是在 realStartActivityLocked() 方法中通过 ClIEntTransaction 对象的 addCallback() 方法增加的

-> LaunchActivityItem#execute()
-> ClIEntTransactionHandler#handleLaunchActivity()

说明：

handleLaunchActivity() 方法在 ClIEntTransactionHandler中定义，由子类 ActivityThread 实现，所以查看 ActivityThread 的 handleLaunchActivity()

-> ActivityThread#performlaunchActivity()

// 通过反射创建Activity对象java.lang.classLoader cl = appContext.getClassLoader();activity = mInstrumentation.newActivity(cl, component.getClassname(), r.intent);// Instrumentation.newActivity 方法public Activity newActivity(ClassLoader cl, String classname,        Intent intent)        throws InstantiationException, illegalaccessexception,        ClassNotFoundException {    String pkg = intent != null && intent.getComponent() != null            ? intent.getComponent().getPackagename() : null;    return getFactory(pkg).instantiateActivity(cl, classname, intent);}// getFactory() 返回 AppComponentFactory 对象// AppComponentFactory.instantiateActivity() 方法通过反射完成类实例对象的创建public @NonNull Activity instantiateActivity(@NonNull ClassLoader cl, @NonNull String classname,        @Nullable Intent intent)        throws InstantiationException, illegalaccessexception, ClassNotFoundException {    return (Activity) cl.loadClass(classname).newInstance();}

-> Instrumentation#newActivity()
-> Activity#attach()
-> Instrumentation#callActivityOnCreate
-> Activity#performCreate()
-> Activity#onCreate()

通过以上过程，最终调用了Activity 的 attach() 和 onCreate() 回调方法，到此为止，我们需要启动的Activity已经完成了对象的创建，并且回调了对应的声明周期方法。到此为止，我们的Activity已经算是正式启动了，只是还需要继续回调其他的声明周期方法以完成对用户可见和可 *** 作的过程。

相关扩展：ContextImpl的创建

在 ActivityThread#performlaunchActivity() 方法中，Instrumentation.newActivity() 之前通过 createBaseContextForActivity() 方法创建了 ContextImpl 对象

ContextImpl appContext = ContextImpl.createActivityContext(            this, r.packageInfo, r.activityInfo, r.token, displayID, r.overrIDeConfig);// ContextImpl.createActivityContext()ContextImpl context = new ContextImpl(null, mainThread, packageInfo, activityInfo.splitname,            activityToken, null, 0, classLoader, null);

Application的创建

在 ActivityThread#performlaunchActivity() 方法中，Instrumentation.newActivity() 创建完 Activity 的实例之后，通过 LoadedApk#makeApplication() 返回了 Application

// LoadedApk.makeApplication()public Application makeApplication(boolean forceDefaultAppClass,        Instrumentation instrumentation) {    if (mApplication != null) {        return mApplication;    }    Application app = null;    String appClass = mApplicationInfo.classname;    if (forceDefaultAppClass || (appClass == null)) {        appClass = "androID.app.Application";    }    try {        java.lang.classLoader cl = getClassLoader();        if (!mPackagename.equals("androID")) {            Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER,                    "initializeJavaContextClassLoader");            initializeJavaContextClassLoader();            Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);        }        ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);        app = mActivityThread.mInstrumentation.newApplication(                cl, appClass, appContext);        appContext.setouterContext(app);    } catch (Exception e) {            }    mActivityThread.mAllApplications.add(app);    mApplication = app;    if (instrumentation != null) {        try {            instrumentation.callApplicationOnCreate(app);        } catch (Exception e) {                 }    }    return app;}

以上代码，先判断 mApplication 是否为null，如果不为null就直接返回，如果为null，表示我们创建的Activity的LaunchActivity（启动Activity），那么就需要创建Application对象，查看 Instrumentation 的 newApplication() 代码中 Application 的创建过程

// Instrumentation.newApplication()public Application newApplication(ClassLoader cl, String classname, Context context)        throws InstantiationException, illegalaccessexception,         ClassNotFoundException {    Application app = getFactory(context.getPackagename())            .instantiateApplication(cl, classname);    app.attach(context);    return app;}// getFactory() 返回 AppComponentFactory 对象// AppComponentFactory.instantiateApplication() 方法通过反射完成类实例对象的创建public @NonNull Application instantiateApplication(@NonNull ClassLoader cl,        @NonNull String classname)        throws InstantiationException, illegalaccessexception, ClassNotFoundException {    return (Application) cl.loadClass(classname).newInstance();}

通过以上代码，我们看到了Application创建完成之后就马上调用了它的attach(context)方法。

最后通过 Instrumentation.callApplicationOnCreate() 调用 Application 的 onCreate() 方法：

if (instrumentation != null) {    try {        instrumentation.callApplicationOnCreate(app);    } catch (Exception e) {         }}public voID callApplicationOnCreate(Application app) {    app.onCreate();}

总结

以上是内存溢出为你收集整理的Android Activity——启动过程探索（一）全部内容，希望文章能够帮你解决Android Activity——启动过程探索（一）所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。