Android-28版本有关AMS回调Activity生命周期的流程

发表于 | 分类于

从Android-28开始，AMS向客户端进程有关Activity部分的通信封装成一个统一的事务来操作，不再直接使用客户端进程ApplicationThread的本地代理了。

版本变化

以startPausingLocked()为例(通知客户端进程执行Activity暂停操作)，看2个版本的变化。
Android-27

1
2
3
4
5
6
7
8
9
10
11
12
13
#ActivityStack
final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping,
        ActivityRecord resuming, boolean pauseImmediately) {
    ...
    if (prev.app != null && prev.app.thread != null) {
        try {
            prev.app.thread.schedulePauseActivity(prev.appToken, prev.finishing,
                    userLeaving, prev.configChangeFlags, pauseImmediately);
        } catch (Exception e) {
        }
    }
    ...
}

Android-28

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#ActivityStack
final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping,
        ActivityRecord resuming, boolean pauseImmediately) {
    ...
    if (prev.app != null && prev.app.thread != null) {
        try {
            mService.getLifecycleManager().scheduleTransaction(prev.app.thread, prev.appToken,
                    PauseActivityItem.obtain(prev.finishing, userLeaving,
                            prev.configChangeFlags, pauseImmediately));
        } catch (Exception e) {
        }
    }
    ...
}

27版本，system_server进程的ActivityStack是直接操作客户端进程ApplicationThread的本地代理的；
28版本，变成AMS调用ClientLifecycleManager.scheduleTransaction()完成，3个参数：客户端进程ApplicationThread的本地代理、客户端进程执行事务Activity所对应的Token、ActivityLifecycleItem，理解为哪个进程的哪个Activity执行什么操作。

AMS通知客户端暂停Activity过程

客户端准备启动Activity前，AMS会把当前栈或其他栈栈顶的Activiy设置为暂停状态。
(在ActivityStack.resumeTopActivityInnerLocked()调用ActivityStackSupervisor.startSpecificActivityLocked()之前)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
ActivityStack
final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping,
        ActivityRecord resuming, boolean pauseImmediately) {
    ...
    if (prev.app != null && prev.app.thread != null) {
        try {
            mService.getLifecycleManager().scheduleTransaction(prev.app.thread, prev.appToken,
                    PauseActivityItem.obtain(prev.finishing, userLeaving,
                            prev.configChangeFlags, pauseImmediately));
        } catch (Exception e) {
        }
    }
    ...
}

mService：AMS。
mService.getLifecycleManager()：ClientLifecycleManager。

ClientLifecycleManager.scheduleTransaction
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#1
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
    final IApplicationThread client = transaction.getClient();
    transaction.schedule();
    if (!(client instanceof Binder)) {
        transaction.recycle();
    }
}
#2
void scheduleTransaction(@NonNull IApplicationThread client, @NonNull IBinder activityToken,
        @NonNull ActivityLifecycleItem stateRequest) throws RemoteException {
    final ClientTransaction clientTransaction = transactionWithState(client, activityToken,stateRequest);
    scheduleTransaction(clientTransaction);
}
#3
void scheduleTransaction(@NonNull IApplicationThread client, @NonNull IBinder activityToken,
        @NonNull ClientTransactionItem callback) throws RemoteException {
    final ClientTransaction clientTransaction = transactionWithCallback(client, activityToken,callback);
    scheduleTransaction(clientTransaction);
}
#4
void scheduleTransaction(@NonNull IApplicationThread client,
        @NonNull ClientTransactionItem callback) throws RemoteException {
    final ClientTransaction clientTransaction = transactionWithCallback(client, null, callback);
    scheduleTransaction(clientTransaction);
}

private static ClientTransaction transactionWithState(@NonNull IApplicationThread client,
        @NonNull IBinder activityToken, @NonNull ActivityLifecycleItem stateRequest) {
    final ClientTransaction clientTransaction = ClientTransaction.obtain(client, activityToken);
    clientTransaction.setLifecycleStateRequest(stateRequest);
    return clientTransaction;
}

private static ClientTransaction transactionWithCallback(@NonNull IApplicationThread client,
        IBinder activityToken, @NonNull ClientTransactionItem callback) {
    final ClientTransaction clientTransaction = ClientTransaction.obtain(client, activityToken);
    clientTransaction.addCallback(callback);
    return clientTransaction;
}

scheduleTransaction方法#2、3、4最终均调用#1。其中:

  • #2参数中的ActivityLifecycleItem是#3参数中ClientTransactionItem的子类；
  • #4少了一个IBinder对象，是因为Activity有可能是ApplicationContext发起的，一个Activity被创建时AMS会同时为其创建一个Token对象，而Application则没有这个Token对象，所以传null；
  • #2、3、4均把参数揉合成一个ClientTransaction，然后调用#1；
  • 这里调用的是#2方法，添加的是ActivityLifecycleItem，，并没有为ClientTransaction添加Callback。
ClientTransaction
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
    public class ClientTransaction implements Parcelable, ObjectPoolItem {

    //客户端准备执行的具体操作，先执行ClientTransactionItem列表再执行ActivityLifecycleItem
    private List<ClientTransactionItem> mActivityCallbacks;
    private ActivityLifecycleItem mLifecycleStateRequest;

    //客户端进程ApplicationThread的本地代理
    private IApplicationThread mClient;

    //客户端进程执行事务Activity所对应的Token，可能为空
    private IBinder mActivityToken;

    ...省略get set方法

    public void preExecute(android.app.ClientTransactionHandler clientTransactionHandler) {
        if (mActivityCallbacks != null) {
            final int size = mActivityCallbacks.size();
            for (int i = 0; i < size; ++i) {
                mActivityCallbacks.get(i).preExecute(clientTransactionHandler, mActivityToken);
            }
        }
        if (mLifecycleStateRequest != null) {
            mLifecycleStateRequest.preExecute(clientTransactionHandler, mActivityToken);
        }
    }
 
    public void schedule() throws RemoteException {
        mClient.scheduleTransaction(this);
    }

    public static ClientTransaction obtain(IApplicationThread client, IBinder activityToken) {
        ClientTransaction instance = ObjectPool.obtain(ClientTransaction.class);
        if (instance == null) {
            instance = new ClientTransaction();
        }
        instance.mClient = client;
        instance.mActivityToken = activityToken;
        return instance;
    }

    // ObjectPoolItem implementation
    ...省略实现缓存池ObjectPoolItem的代码

    // Parcelable implementation
    ...省略实现Parcelable的代码
}

可以看到，ClientTransaction仅仅是简单的封装了IApplicationThread本地代理、客户端的ActivityToken、代表具体操作的ClientTransactionItem列表和ActivityLifecycleItem。ClientTransaction具有跨进程通信能力，当然ClientTransactionItem也具有跨进程能力。

封装好ClientTransaction后，执行ClientTransaction.schedule()，熟悉Binder通信的原理后可知，经由Binder驱动最终客户端进程的ApplicationThread.scheduleTransaction(ClientTransaction)。后面的操作均在客户端进程中。

ApplicationThread.scheduleTransaction
1
2
3
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
    ActivityThread.this.scheduleTransaction(transaction);
}

ClientTransactionHandler是ActivityThread的父类，scheduleTransaction方法由ClientTransactionHandler中实现

ClientTransactionHandler.scheduleTransaction
1
2
3
4
void scheduleTransaction(ClientTransaction transaction) {
    transaction.preExecute(this);
    sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}

sendMessage()在ActivityThread中实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void sendMessage(int what, Object obj) {
    sendMessage(what, obj, 0, 0, false);
}

private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
    Message msg = Message.obtain();
    msg.what = what;
    msg.obj = obj;
    msg.arg1 = arg1;
    msg.arg2 = arg2;
    if (async) {
        msg.setAsynchronous(true);
    }
    mH.sendMessage(msg);
}

其中mH是ActivityThread内部类H，是一个Handler，直接看handleMessage()

1
2
3
4
5
6
7
8
9
10
11
public void handleMessage(Message msg) {
        switch (msg.what) {
            case EXECUTE_TRANSACTION:
                final ClientTransaction transaction = (ClientTransaction) msg.obj;
                mTransactionExecutor.execute(transaction);
                if (isSystem()) {
                    transaction.recycle();
                }
                break;
        }
    }

mTransactionExecutor:TransactionExecutor，客户端统一处理事务的类。

TransactionExecutor
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
public class TransactionExecutor {

//其实就是ActivityThread。
private ClientTransactionHandler mTransactionHandler;
private PendingTransactionActions mPendingActions = new PendingTransactionActions();
//辅助调用cycleToPath方法
private TransactionExecutorHelper mHelper = new TransactionExecutorHelper();

public TransactionExecutor(ClientTransactionHandler clientTransactionHandler) {
    mTransactionHandler = clientTransactionHandler;
}

public void execute(ClientTransaction transaction) {
    final IBinder token = transaction.getActivityToken();
    //循环执行ClientTransactionItem列表的execute()和postExecute()
    executeCallbacks(transaction);
    //执行ActivityLifecycleItem，执行其execute()和postExecute()
    executeLifecycleState(transaction);
    mPendingActions.clear();
}

public void executeCallbacks(ClientTransaction transaction) {
    final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
    if (callbacks == null) {
        return;
    }
    //取出Token
    final IBinder token = transaction.getActivityToken();
    ActivityClientRecord r = mTransactionHandler.getActivityClient(token);

    final ActivityLifecycleItem finalStateRequest = transaction.getLifecycleStateRequest();
    final int finalState = finalStateRequest != null ? finalStateRequest.getTargetState()
            : UNDEFINED;
    final int lastCallbackRequestingState = lastCallbackRequestingState(transaction);

    final int size = callbacks.size();
    for (int i = 0; i < size; ++i) {
        //循环取出ClientTransactionItem
        final ClientTransactionItem item = callbacks.get(i);
        final int postExecutionState = item.getPostExecutionState();
        final int closestPreExecutionState = mHelper.getClosestPreExecutionState(r,
                item.getPostExecutionState());
        if (closestPreExecutionState != UNDEFINED) {
            cycleToPath(r, closestPreExecutionState);
        }
        item.execute(mTransactionHandler, token, mPendingActions);
        item.postExecute(mTransactionHandler, token, mPendingActions);
        if (r == null) {
            r = mTransactionHandler.getActivityClient(token);
        }
        if (postExecutionState != UNDEFINED && r != null) {
            final boolean shouldExcludeLastTransition =
                    i == lastCallbackRequestingState && finalState == postExecutionState;
            cycleToPath(r, postExecutionState, shouldExcludeLastTransition);
        }
    }
}

private void executeLifecycleState(ClientTransaction transaction) {
    //取出ActivityLifecycleItem
    final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
    if (lifecycleItem == null) {
        return;
    }
    //取出Token
    final IBinder token = transaction.getActivityToken();
    final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
    if (r == null) {
        return;
    }
    cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */);
    lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
    lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}

public void cycleToPath(ActivityClientRecord r, int finish) {
    cycleToPath(r, finish, false /* excludeLastState */);
}

private void cycleToPath(ActivityClientRecord r, int finish,boolean excludeLastState) {
    final int start = r.getLifecycleState();
    final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
    performLifecycleSequence(r, path);
}

private void performLifecycleSequence(ActivityClientRecord r, IntArray path) {
    final int size = path.size();
    for (int i = 0, state; i < size; i++) {
        state = path.get(i);
        log("Transitioning to state: " + state);
        switch (state) {
            case ON_CREATE:
                mTransactionHandler.handleLaunchActivity(r, mPendingActions,
                        null /* customIntent */);
                break;
            case ON_START:
                mTransactionHandler.handleStartActivity(r, mPendingActions);
                break;
            case ON_RESUME:
                mTransactionHandler.handleResumeActivity(r.token, false /* finalStateRequest */,
                        r.isForward, "LIFECYCLER_RESUME_ACTIVITY");
                break;
            case ON_PAUSE:
                mTransactionHandler.handlePauseActivity(r.token, false /* finished */,
                        false /* userLeaving */, 0 /* configChanges */, mPendingActions,
                        "LIFECYCLER_PAUSE_ACTIVITY");
                break;
            case ON_STOP:
                mTransactionHandler.handleStopActivity(r.token, false /* show */,
                        0 /* configChanges */, mPendingActions, false /* finalStateRequest */,
                        "LIFECYCLER_STOP_ACTIVITY");
                break;
            case ON_DESTROY:
                mTransactionHandler.handleDestroyActivity(r.token, false /* finishing */,
                        0 /* configChanges */, false /* getNonConfigInstance */,
                        "performLifecycleSequence. cycling to:" + path.get(size - 1));
                break;
            case ON_RESTART:
                mTransactionHandler.performRestartActivity(r.token, false /* start */);
                break;
            default:
                throw new IllegalArgumentException("Unexpected lifecycle state: " + state);
            }
        }
    }
}

execute()处理ClientTransaction，先调用executeCallbacks()取出ClientTransaction中的ClientTransactionItem列表，便利然后调用ClientTransactionItem的execute()和postExecute()；然后调用executeLifecycleState()，取出ClientTransaction中的ActivityLifecycleItem，调用ClientTransactionItem的execute()和postExecute()。转了一圈，终于执行ClientTransactionItem了。

关于cycleToPath()方法的作用是。当Activity的生命周期的状态从状态A切换到状态B时，执行其中间未执行到的状态。例：

  • Activity从前台进入后台，RESUME到PAUSE，中间没有其他状态则实际没有执行什么；
  • Activity从创建到显示，CREATE到RESUME，会执行CREATE到RESUME中间的START状态(见ActivityStackSupervisor.realStartActivityLocked())。
    这就解释了为什么AMS创建并显示Activity时，只使用了LaunchActivityItem和ResumeActivityItem，但也执行了AT.handleStartActivity()的缘故。

回到暂停Activity的代码中，这里没有向ClientTransaction添加Callback，而ClientTransaction中的ActivityLifecycleItem便是PauseActivityItem。

PauseActivityItem
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public class PauseActivityItem extends ActivityLifecycleItem {

    private boolean mFinished;
    private boolean mUserLeaving;
    private int mConfigChanges;
    private boolean mDontReport;

    @Override
    public void execute(ClientTransactionHandler client, IBinder token,
            PendingTransactionActions pendingActions) {
        client.handlePauseActivity(token, mFinished, mUserLeaving, mConfigChanges, pendingActions,
                "PAUSE_ACTIVITY_ITEM");
    }

    @Override
    public void postExecute(ClientTransactionHandler client, IBinder token,
            PendingTransactionActions pendingActions) {
        if (mDontReport) {
            return;
        }
        try {
            ActivityManager.getService().activityPaused(token);
        } catch (RemoteException ex) {
            throw ex.rethrowFromSystemServer();
        }
    }

    public static PauseActivityItem obtain(boolean finished, boolean userLeaving, int configChanges,
            boolean dontReport) {
        PauseActivityItem instance = ObjectPool.obtain(PauseActivityItem.class);
        if (instance == null) {
            instance = new PauseActivityItem();
        }
        instance.mFinished = finished;
        instance.mUserLeaving = userLeaving;
        instance.mConfigChanges = configChanges;
        instance.mDontReport = dontReport;
        return instance;
    }
}

主要方法：
obtain()：生成PauseActivityItem对象并对属性赋值。
execute()：客户端进程ActivityThread准备执行的方法(ClientTransactionHandler定义ActivityThread实现)。
postExecute()：给AMS的反馈。

execute()方法调用了ActivityThread.handlePauseActivity()

ActivityThread.handlePauseActivity
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public void handlePauseActivity(IBinder token, boolean finished, boolean userLeaving,
        int configChanges, PendingTransactionActions pendingActions, String reason) {
    ActivityClientRecord r = mActivities.get(token);
    if (r != null) {
        if (userLeaving) {
            performUserLeavingActivity(r);
        }
        r.activity.mConfigChangeFlags |= configChanges;
        performPauseActivity(r, finished, reason, pendingActions);

        if (r.isPreHoneycomb()) {
            QueuedWork.waitToFinish();
        }
        mSomeActivitiesChanged = true;
    }
}

到这里就是熟悉的代码了，不再分析。

总结大致流程

android-28-AMS_ipc2Activity_lifecycle

  • AMS跨进程和客户端进程通信有关Activity的重要的生命周期，均由ClientLifecycleManager.scheduleTransaction()完成。

  • 把Activity准备执行的行为抽象到ActivityLifecycleItem中，根据不同的场景编写相应代码；把Activity准备执行必备参数和ActivityLifecycleItem封装到ClientTransaction中。

  • AMS跨进程传输ClientTransaction，客户端进程ApplicationThread接收，然后发送到主线程ActivityThread，最后由TransactionExecutor统一解析。

  • AMS封装并传输ClientTransaction，统一接口；客户端进程接收ClientTransaction并使用TransactionExecutor解析AMS的请求，再根据ActivityLifecycleItem执行不同的代码。

  • ActivityLifecycleItem的实现在“…/android-28/android/app/servertransaction/”目录下，Activity生命周期相关的方法LaunchActivityItem、ResumeActivityItem、PauseActivityItem、StopActivityItem、DestroyActivityItem，Activity的Configuration变化的回调、ActivityResult、onNewIntent等等。基本上其他的ActivityLifecycleItem是一样的原理。均在execute()方法中调用ActivityThread相关方法的。