/**
 * 定义{@link android.app.servertransaction.ClientTransaction}或其项可以在客户端上执行的操作。
 * @hide
 */
public abstract class ClientTransactionHandler {
    // 安排与阶段相关的逻辑和处理程序。
    /** 准备并安排事物执行。 */
    void scheduleTransaction(ClientTransaction transaction) {
        transaction.preExecute(this);
        sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
    }
}

/**
 * 它管理应用程序进程中主线程的执行、调度和执行活动、广播以及活动管理器请求的其他操作。
 *
 * {@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));
        }
    }
}

/**
 * 类以正确的顺序管理事务执行。
 * @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);
        }
    }
}

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));
    }
}

/**
 * 请求启动 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);
}