文章目录
- 前言
- 一、ClientTransactionHandler.scheduleTransaction
- 二、ActivityThread.H 处理 EXECUTE_TRANSACTION 消息
- 三、TransactionExecutor execute -> executeCallbacks 方法
- 四、LaunchActivityItem.execute
- 总结
前言
上一篇博客 【Android 启动过程】Activity 启动源码分析 ( AMS -＞ ActivityThread、AMS 线程阶段 二 ) 分析到 , 在 AMS 进程通过 Binder 机制调用 ActivityThread 中的 ApplicationThread 内部类中 scheduleTransaction 方法 ;
在该方法中 , 发送了 ActivityThread.H.EXECUTE_TRANSACTION
消息 , 由 ActivityThread 中的内部类 H 处理该消息 ;
从 Binder 调用 ActivityThread 开始 , 就进入了主线程阶段开始执行 , 这里开始在主线程中创建 Activity , 并启动该 Activity ;
一、ClientTransactionHandler.scheduleTransaction
在 ClientTransactionHandler.scheduleTransaction 方法中 , 发送了
消息 , 并且将参数 ClientTransaction transaction 传递给了 ActivityThread.H ;
/**
* 定义{@link android.app.servertransaction.ClientTransaction}或其项可以在客户端上执行的操作。
* @hide
*/
public abstract class ClientTransactionHandler {
// 安排与阶段相关的逻辑和处理程序。
/** 准备并安排事物执行。 */
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
}完整代码参考 /frameworks/base/core/java/android/app/ClientTransactionHandler.java ;
二、ActivityThread.H 处理 EXECUTE_TRANSACTION 消息
在 ActivityThread 的 H 内部类中 , 处理 int EXECUTE_TRANSACTION = 159 消息时 , 获取传入的 ClientTransaction transaction 对象 , 并执行该事务 mTransactionExecutor.execute(transaction) ;
mTransactionExecutor 是 ActivityThread 成员变量 , 是执行多步骤事务的执行者 ;
/**
* 它管理应用程序进程中主线程的执行、调度和执行活动、广播以及活动管理器请求的其他操作。
*
* {@hide}
*/
public final class ActivityThread extends ClientTransactionHandler {
// 执行多步骤事务的执行者。
private final TransactionExecutor mTransactionExecutor = new TransactionExecutor(this);
class H extends Handler {
public static final int EXECUTE_TRANSACTION = 159;
public void handleMessage(Message msg) {
if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " codeToString(msg.what));
switch (msg.what) {
case EXECUTE_TRANSACTION:
// ActivityThread 调用 scheduleTransaction 方法发送 159 消息时
// 将 transaction 传递到了 H 中
// 此处获取该 transaction
final ClientTransaction transaction = (ClientTransaction) msg.obj;
// 执行 transaction 相关信息
mTransactionExecutor.execute(transaction);
if (isSystem()) {
// 系统进程内的客户端事务在客户端而不是ClientLifecycleManager上循环，
// 以避免在处理此消息之前被清除。
transaction.recycle();
}
// TODO(lifecycler): 回收本地计划的事务。
break;
}
Object obj = msg.obj;
if (obj instanceof SomeArgs) {
((SomeArgs) obj).recycle();
}
if (DEBUG_MESSAGES) Slog.v(TAG, "<<< done: " codeToString(msg.what));
}
}
}完整代码参考 /frameworks/base/core/java/android/app/ActivityThread.java
三、TransactionExecutor execute -> executeCallbacks 方法
分析 ActivityThread 的 TransactionExecutor mTransactionExecutor = new TransactionExecutor(this) 成员的 mTransactionExecutor.execute(transaction) 方法 , 执行事务的过程 ;
传入的参数 ClientTransaction transaction 实际上就是 ActivityThread ;
在 execute 方法中 , 调用了 executeCallbacks 方法 , 在该方法中从 ClientTransaction 获取 ClientTransactionItem 集合 , 最终调用 了 ClientTransactionItem 的 execute 方法 , item.execute(mTransactionHandler, token, mPendingActions) ;
/**
* 类以正确的顺序管理事务执行。
* @hide
*/
public class TransactionExecutor {
/**
* 解决事务。
* 首先，所有回调将按照它们在列表中出现的顺序执行。
* 如果回调需要特定的执行前或执行后状态，则客户端将相应地进行转换。
* 然后，客户端将循环到最终生命周期状态（如果提供）。
* 否则，它将保持初始状态或回调所需的最后状态。
*/
public void execute(ClientTransaction transaction) {
final IBinder token = transaction.getActivityToken();
log("Start resolving transaction for client: " mTransactionHandler ", token: " token);
executeCallbacks(transaction);
executeLifecycleState(transaction);
mPendingActions.clear();
log("End resolving transaction");
}
/** 循环检查回调请求的所有状态，并在适当的时间执行它们。 */
@VisibleForTesting
public void executeCallbacks(ClientTransaction transaction) {
// 从 ClientTransaction 获取 ClientTransactionItem 集合
final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
// 遍历 ClientTransactionItem 集合 , 并执行 ClientTransactionItem 的 execute 方法
final int size = callbacks.size();
for (int i = 0; i < size; i) {
final ClientTransactionItem item = callbacks.get(i);
item.execute(mTransactionHandler, token, mPendingActions);
item.postExecute(mTransactionHandler, token, mPendingActions);
}
}
}完整代码参考 /frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java ;
上面 TransactionExecutor 中的 executeCallbacks 中遍历的 ClientTransactionItem 集合元素是在 ActivityStackSupervisor 的 realStartActivityLocked 方法的 LaunchActivityItem.obtain(new Intent(r.intent) 码中设置的 ;
public class ActivityStackSupervisor extends ConfigurationContainer implements DisplayListener,
RecentTasks.Callbacks {
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
boolean andResume, boolean checkConfig) throws RemoteException {
// Create activity launch transaction.
final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread,
r.appToken);
clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
System.identityHashCode(r), r.info,
// TODO: Have this take the merged configuration instead of separate global
// and override configs.
mergedConfiguration.getGlobalConfiguration(),
mergedConfiguration.getOverrideConfiguration(), r.compat,
r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
r.persistentState, results, newIntents, mService.isNextTransitionForward(),
profilerInfo));
}
}完整代码参考 /frameworks/base/services/core/java/com/android/server/am/ActivityStackSupervisor.java ;
四、LaunchActivityItem.execute
在 TransactionExecutor.executeCallbacks 中调用了 item.execute(mTransactionHandler, token, mPendingActions) 代码 , 下面继续分析 ClientTransactionItem 的 execute 方法 ,
这里的 ClientTransactionItem 实际上是 LaunchActivityItem , LaunchActivityItem 的 execute 创建 ActivityClientRecord 封装了启动 Activity 的所有必要信息 ,
client.handleLaunchActivity(r, pendingActions, null /* customIntent */) 代码 , client 就是 ActivityThread , 最终调用的是 ActivityThread 的 handleLaunchActivity 方法 ;
/**
* 请求启动 Activity 。
* @hide
*/
public class LaunchActivityItem extends ClientTransactionItem {
@Override
public void preExecute(ClientTransactionHandler client, IBinder token) {
client.updateProcessState(mProcState, false);
client.updatePendingConfiguration(mCurConfig);
}
@Override
public void execute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,
mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState,
mPendingResults, mPendingNewIntents, mIsForward,
mProfilerInfo, client);
client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
} 完整代码参考 /frameworks/base/core/java/android/app/servertransaction/LaunchActivityItem.java ;
总结
发送消息给 ActivityThread.H , 然后经过上述一系列调用 , 获取到了启动 Activity 的所有数据 , 又回到 ActivityThread 中执行 handleLaunchActivity 方法 ;
