ClientLifecycleManager机制

基于Android R版本分析

简介

生命周期管理是google在Android P引入的设计，在Android P之前，Activity存在生命周期的概念，但并无生命周期管理这个概念。

为了方便生命周期的切换以及相关业务的管理，google采用了事务的思想，将生命周期抽象为客户端事务的一部分来统一管理。

总体设计

架构

所有的声明周期管理的入口都是从ClientLifecycleManager，该变量是在ActivityTaskManagerService中构造的；

整体的逻辑分为几个过程：

• system_server调用方通过ATMS获取到ClientLifecycleManager实例；
• 构造ClientTransaction实例，其中包含了本次事务需要的所有的信息，包括client、activityToken以及ClientTransactionItem实例，ClientTransaction实例的构造方式存在多种形式，需要根据具体的场景定制特定的ClientTransaction实例；
• ClientTransaction实例创建成功之后，通过ClientLifecycleManager#scheduleTransaction()方法，调用ClientTransaction实例中存储的IApplicationThread类型的client变量，调用其scheduleTransaction()方法，该方法中传入了ClientTransaction实例，其中IApplicationThread为aidl，本质上就是跨进程调用，将ClientTransaction实例通过跨进程的方式传递给应用侧；
• ActivityThread中的ApplicationThread实现了IApplicationThread的aidl具体逻辑，最终还是调用回了ActivityThread；
• ActivityThread需要针对ClientTransaction实例进行解析，根据实际传入的信息进行对应的ClientTransactionItem的事务分发；

至此，ClientLifecycleManager的机制基本上的结束了，后续就是ActivityThread后续根据实际的场景执行对应的具体业务逻辑；

类图

大致的描述了一下各个类之间的结构关系，其中ClientTransactionItem是一个比较关键的类，其各个子类各代表了一种具体的业务场景，system_server在处理不同场景的时候，会根据真正的业务场景创建对应的ClientTransactionItem实例传递给ActivityThread中；

相关类说明

• ClientLifecycleManager：客户端事务管理类，包括且不限于处理Activity生命周期转换事务，同时也包括 与客户端相关的其他事务处理；
• ClientTransaction：事务集类，一个事务集可以存放一系列Callback事务及一个生命周期事务；
• TransactionExecutor：事务执行器，让事务以正确的顺序执行；
• BaseClientRequest：事务的抽象类，定义了preExecute、execute、postExecute三个接口，分别代表事务执行前、执行中、执行后三个阶段的回调方法；
• ActivityLifecycleItem：abstract class，Activity生命周期事务类，其子类有DestroyActivityItem、PauseActivityItem、StopActivityItem、ResumeActivityItem等等，表示具体的activity生命周期转换事务；
• ClientTransaction：abstract class,客户端事务类，ActivityLifecycleItem是它的子类之一；

ClientTransaction

Transaction Name	Desc
ConfigurationChangeItem	App configuration 改变的消息
WindowVisibilityItem	Window可见性发生改变的消息
MoveToDisplayItem	Activity 移动到不同的显示设备的消息
MultiWindowModeChangeItem	多窗口模式改变的消息
ActivityConfigurationChangeItem	Activity configuration 改变的回调
PipModeChangeItem	画中画模式改变的消息
ActivityResultItem	Activity result的回调
NewIntentItem	New intent消息
TopResumedActivityChangeItem	Top resumed activity 改变的回调
ActivityRelaunchItem	重启Activity的回调
LaunchActivityItem	请求启动一个Activity

scheduleTransaction

scheduleTransaction()是定义在ClientLifecycleManager中，该方法中存在多个重载方法；

/**
 * Schedule a transaction, which may consist of multiple callbacks and a lifecycle request.
 * @param transaction A sequence of client transaction items.
 * @throws RemoteException
 *
 * @see ClientTransaction
 */
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
    final IApplicationThread client = transaction.getClient();
    transaction.schedule();
    if (!(client instanceof Binder)) {
        // If client is not an instance of Binder - it's a remote call and at this point it is
        // safe to recycle the object. All objects used for local calls will be recycled after
        // the transaction is executed on client in ActivityThread.
        transaction.recycle();
    }
}
​
/**
 * Schedule a single lifecycle request or callback to client activity.
 * @param client Target client.
 * @param activityToken Target activity token.
 * @param stateRequest A request to move target activity to a desired lifecycle state.
 * @throws RemoteException
 *
 * @see ClientTransactionItem
 */
void scheduleTransaction(@NonNull IApplicationThread client, @NonNull IBinder activityToken,
        @NonNull ActivityLifecycleItem stateRequest) throws RemoteException {
    final ClientTransaction clientTransaction = transactionWithState(client, activityToken,
            stateRequest);
    scheduleTransaction(clientTransaction);
}
​
/**
 * Schedule a single callback delivery to client activity.
 * @param client Target client.
 * @param activityToken Target activity token.
 * @param callback A request to deliver a callback.
 * @throws RemoteException
 *
 * @see ClientTransactionItem
 */
void scheduleTransaction(@NonNull IApplicationThread client, @NonNull IBinder activityToken,
        @NonNull ClientTransactionItem callback) throws RemoteException {
    final ClientTransaction clientTransaction = transactionWithCallback(client, activityToken,
            callback);
    scheduleTransaction(clientTransaction);
}
​
/**
 * Schedule a single callback delivery to client application.
 * @param client Target client.
 * @param callback A request to deliver a callback.
 * @throws RemoteException
 *
 * @see ClientTransactionItem
 */
void scheduleTransaction(@NonNull IApplicationThread client,
        @NonNull ClientTransactionItem callback) throws RemoteException {
    final ClientTransaction clientTransaction = transactionWithCallback(client,
            null /* activityToken */, callback);
    scheduleTransaction(clientTransaction);
}

这几个重载方法的区别之处就在于ClientTransaction创建形式的差异；

机制流程分析

ClientTransactionItem存在很多子类，每一个子类对应场景，我们以两个场景为例，说明一下具体的流程分析；

LaunchActivityItem

dupz_stack: onCreate: 
dupz_stack: java.lang.Exception: dupz_stack onCreate
dupz_stack:     at com.nobo.adapterdemo.MainActivity.onCreate(MainActivity.java:46)
dupz_stack:     at android.app.Activity.performCreate(Activity.java:8034)
dupz_stack:     at android.app.Activity.performCreate(Activity.java:8018)
dupz_stack:     at android.app.Instrumentation.callActivityOnCreate(Instrumentation.java:1312)
dupz_stack:     at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:3444)
dupz_stack:     at android.app.ActivityThread.handleLaunchActivity(ActivityThread.java:3635)
dupz_stack:     at android.app.servertransaction.LaunchActivityItem.execute(LaunchActivityItem.java:85)
dupz_stack:     at android.app.servertransaction.TransactionExecutor.executeCallbacks(TransactionExecutor.java:135)
dupz_stack:     at android.app.servertransaction.TransactionExecutor.execute(TransactionExecutor.java:95)
dupz_stack:     at android.app.ActivityThread$H.handleMessage(ActivityThread.java:2101)
dupz_stack:     at android.os.Handler.dispatchMessage(Handler.java:106)
dupz_stack:     at android.os.Looper.loop(Looper.java:223)
dupz_stack:     at android.app.ActivityThread.main(ActivityThread.java:7811)
dupz_stack:     at java.lang.reflect.Method.invoke(Native Method)
dupz_stack:     at com.android.internal.os.RuntimeInit$MethodAndArgsCaller.run(RuntimeInit.java:592)
dupz_stack:     at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:951)

我们之前分析过，realStartActivityLocked()方法的调用调用了Activity真正start()，这个过程中伴随着两个判断条件：

• 上一个ActivityRecord完成Pause逻辑；
• 当前的Activity执行完bindApplication之后；

上述的两个条件全部满足之后，realStartActivityLocked()才会被真正执行，在这个过程中，创建对应的LaunchActivityItem实例，然后再创建ClientTransaction实例，该实例中需要封装刚刚创建好的ClientTransactionItem子类，然后通过ClientLifecycleManager将创建好的ClientTransaction实例通过scheduleTransaction()方法发送至应用侧，至此，应用侧就接收到了本次需要处理的事务；

我们在创建LaunchActivityItem的时候，是调用的ClientTransaction的addCallback()方法将其LaunchActivityItem实例传入的，后续在应用侧则也是通过executeCallback()、getCallback()的形式获取对应的ClientTransactionItem实例来执行相应的逻辑；

最终，会创建应用侧的Activity实例并触发Activity的onCreate()方法，同时将ActivityThread的状态修改为ON_CREATE状态；

ActivityLifecycleItem

ActivityLifecycleItem存在多个子类，每个子类对应一个场景，我们就以ResumeActivityItem场景为例，描述一下具体的调用流程；

dupz_stack: onResume: 
dupz_stack: java.lang.Exception: dupz_stack  onResume
dupz_stack:     at com.nobo.adapterdemo.MainActivity.onResume(MainActivity.java:124)
dupz_stack:     at android.app.Instrumentation.callActivityOnResume(Instrumentation.java:1459)
dupz_stack:     at android.app.Activity.performResume(Activity.java:8169)
dupz_stack:     at android.app.ActivityThread.performResumeActivity(ActivityThread.java:4494)
dupz_stack:     at android.app.ActivityThread.handleResumeActivity(ActivityThread.java:4536)
dupz_stack:     at android.app.servertransaction.ResumeActivityItem.execute(ResumeActivityItem.java:52)
dupz_stack:     at android.app.servertransaction.TransactionExecutor.executeLifecycleState(TransactionExecutor.java:176)
dupz_stack:     at android.app.servertransaction.TransactionExecutor.execute(TransactionExecutor.java:97)
dupz_stack:     at android.app.ActivityThread$H.handleMessage(ActivityThread.java:2101)
dupz_stack:     at android.os.Handler.dispatchMessage(Handler.java:106)
dupz_stack:     at android.os.Looper.loop(Looper.java:223)
dupz_stack:     at android.app.ActivityThread.main(ActivityThread.java:7811)
dupz_stack:     at java.lang.reflect.Method.invoke(Native Method)
dupz_stack:     at com.android.internal.os.RuntimeInit$MethodAndArgsCaller.run(RuntimeInit.java:592)
dupz_stack:     at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:951)

我们在分析onCreate的过程中，其实还伴随着ResumeActivityItem的创建和scheduleTransaction()，我们这里就不再描述，我们简单的说明一下即可；

// Set desired final state.
final ActivityLifecycleItem lifecycleItem;
if (andResume) {
    lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward());
} else {
    lifecycleItem = PauseActivityItem.obtain();
}
clientTransaction.setLifecycleStateRequest(lifecycleItem);

在这个过程中，将创建好的ResumeActivityItem实例赋值给了ClientTransaction中的mLifecycleStateRequest变量；

onResume过程其实是比较简单的，但是在这个过程中，涉及到了一个很重要的过程：

• handleResumeActivity

我们之前在讲述DrawState概念的时候，涉及到这个方法，由此我们知道，在onResume执行完成之后，并不代表的应用已经可见了，而是仅仅代表了Client开始进行窗口的创建、绘制以及提交等一些操作；

onStart

dupz_stack: onStart: 
dupz_stack: java.lang.Exception: dupz_stack  onStart
dupz_stack:     at com.nobo.adapterdemo.MainActivity.onStart(MainActivity.java:137)
dupz_stack:     at android.app.Instrumentation.callActivityOnStart(Instrumentation.java:1438)
dupz_stack:     at android.app.Activity.performStart(Activity.java:8058)
dupz_stack:     at android.app.ActivityThread.handleStartActivity(ActivityThread.java:3497)
dupz_stack:     at android.app.servertransaction.TransactionExecutor.performLifecycleSequence(TransactionExecutor.java:221)
dupz_stack:     at android.app.servertransaction.TransactionExecutor.cycleToPath(TransactionExecutor.java:201)
dupz_stack:     at android.app.servertransaction.TransactionExecutor.executeLifecycleState(TransactionExecutor.java:173)
dupz_stack:     at android.app.servertransaction.TransactionExecutor.execute(TransactionExecutor.java:97)
dupz_stack:     at android.app.ActivityThread$H.handleMessage(ActivityThread.java:2101)
dupz_stack:     at android.os.Handler.dispatchMessage(Handler.java:106)
dupz_stack:     at android.os.Looper.loop(Looper.java:223)
dupz_stack:     at android.app.ActivityThread.main(ActivityThread.java:7811)
dupz_stack:     at java.lang.reflect.Method.invoke(Native Method)
dupz_stack:     at com.android.internal.os.RuntimeInit$MethodAndArgsCaller.run(RuntimeInit.java:592)
dupz_stack:     at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:951)

onStart()的调用，从堆栈调用上看，好像没有通过StartActivityItem触发，这个后续再调研StartActivityItem是在什么情况下使用；

onPause

dupz_stack: onPause: dupz
dupz_stack: java.lang.Exception: dupz_stack onPause
dupz_stack:     at com.nobo.adapterdemo.MainActivity.onPause(MainActivity.java:161)
dupz_stack:     at android.app.Activity.performPause(Activity.java:8208)
dupz_stack:     at android.app.Instrumentation.callActivityOnPause(Instrumentation.java:1513)
dupz_stack:     at android.app.ActivityThread.performPauseActivityIfNeeded(ActivityThread.java:4801)
dupz_stack:     at android.app.ActivityThread.performPauseActivity(ActivityThread.java:4762)
dupz_stack:     at android.app.ActivityThread.handlePauseActivity(ActivityThread.java:4713)
dupz_stack:     at android.app.servertransaction.PauseActivityItem.execute(PauseActivityItem.java:46)
dupz_stack:     at android.app.servertransaction.TransactionExecutor.executeLifecycleState(TransactionExecutor.java:176)
dupz_stack:     at android.app.servertransaction.TransactionExecutor.execute(TransactionExecutor.java:97)
dupz_stack:     at android.app.ActivityThread$H.handleMessage(ActivityThread.java:2101)
dupz_stack:     at android.os.Handler.dispatchMessage(Handler.java:106)
dupz_stack:     at android.os.Looper.loop(Looper.java:223)
dupz_stack:     at android.app.ActivityThread.main(ActivityThread.java:7811)
dupz_stack:     at java.lang.reflect.Method.invoke(Native Method)
dupz_stack:     at com.android.internal.os.RuntimeInit$MethodAndArgsCaller.run(RuntimeInit.java:592)
dupz_stack:     at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:951)

在system_server端，pause的过程还是比较简单的，Activity响应onBackPressed()，执行了对应的finish()，finish()会触发ATMS的finishIfPossible()逻辑， 从而最终创建了对应的PauseActivityItem实例，然后构建ClientTransaction事务，最终通过ClientLifecycleManager传递至应用端；

应用侧也非常简单，执行对应的ClientTransaction，最终会触发Activity的onPause；

onStop

dupz_stack: onStop: dupz
dupz_stack: java.lang.Exception: dupz_stack onStop
dupz_stack:     at com.nobo.adapterdemo.MainActivity.onStop(MainActivity.java:178)
dupz_stack:     at android.app.Instrumentation.callActivityOnStop(Instrumentation.java:1479)
dupz_stack:     at android.app.Activity.performStop(Activity.java:8249)
dupz_stack:     at android.app.ActivityThread.callActivityOnStop(ActivityThread.java:4916)
dupz_stack:     at android.app.ActivityThread.performStopActivityInner(ActivityThread.java:4895)
dupz_stack:     at android.app.ActivityThread.handleStopActivity(ActivityThread.java:4969)
dupz_stack:     at android.app.servertransaction.TransactionExecutor.performLifecycleSequence(TransactionExecutor.java:233)
dupz_stack:     at android.app.servertransaction.TransactionExecutor.cycleToPath(TransactionExecutor.java:201)
dupz_stack:     at android.app.servertransaction.TransactionExecutor.executeLifecycleState(TransactionExecutor.java:173)
dupz_stack:     at android.app.servertransaction.TransactionExecutor.execute(TransactionExecutor.java:97)
dupz_stack:     at android.app.ActivityThread$H.handleMessage(ActivityThread.java:2101)
dupz_stack:     at android.os.Handler.dispatchMessage(Handler.java:106)
dupz_stack:     at android.os.Looper.loop(Looper.java:223)
dupz_stack:     at android.app.ActivityThread.main(ActivityThread.java:7811)
dupz_stack:     at java.lang.reflect.Method.invoke(Native Method)
dupz_stack:     at com.android.internal.os.RuntimeInit$MethodAndArgsCaller.run(RuntimeInit.java:592)
dupz_stack:     at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:951)

onStop逻辑和onStart逻辑比较类似，在整个过程中，好像没有对应StopActivityItem的创建，后续再具体分析把；

onDestroy

dupz_stack: onDestroy: dupz
dupz_stack: java.lang.Exception: dupz_stack onDestroy
dupz_stack:     at com.nobo.adapterdemo.MainActivity.onDestroy(MainActivity.java:197)
dupz_stack:     at android.app.Activity.performDestroy(Activity.java:8279)
dupz_stack:     at android.app.Instrumentation.callActivityOnDestroy(Instrumentation.java:1347)
dupz_stack:     at android.app.ActivityThread.performDestroyActivity(ActivityThread.java:5162)
dupz_stack:     at android.app.ActivityThread.handleDestroyActivity(ActivityThread.java:5207)
dupz_stack:     at android.app.servertransaction.DestroyActivityItem.execute(DestroyActivityItem.java:44)
dupz_stack:     at android.app.servertransaction.TransactionExecutor.executeLifecycleState(TransactionExecutor.java:176)
dupz_stack:     at android.app.servertransaction.TransactionExecutor.execute(TransactionExecutor.java:97)
dupz_stack:     at android.app.ActivityThread$H.handleMessage(ActivityThread.java:2101)
dupz_stack:     at android.os.Handler.dispatchMessage(Handler.java:106)
dupz_stack:     at android.os.Looper.loop(Looper.java:223)
dupz_stack:     at android.app.ActivityThread.main(ActivityThread.java:7811)
dupz_stack:     at java.lang.reflect.Method.invoke(Native Method)
dupz_stack:     at com.android.internal.os.RuntimeInit$MethodAndArgsCaller.run(RuntimeInit.java:592)
dupz_stack:     at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:951)

这个Destroy过程还是比较特殊的，需要分为两种情况：

• 无动效或动效已执行完成；
• 有动效且还正在animating；

针对第二种情况，其实也会触发sendEmptyMessage = IDLE_NOW_MSG，但是在后续的逻辑判断中，会判断当前即将执行destroy的ActivityRecord动效是否执行完毕，如果没有，则不会在本次的处理过程中；

在有退场动效的情况下，只有退场动效执行完毕，才能真正的destroy对应的Activity；

基本上就是一些状态的置空或者是销毁等逻辑；