Activity启动流程分析三 ActivityStackSupervisor启动Activity ClientTransaction在AMS和App之间的通信

ActivityStackSupervisor启动Activity

在之前的分析里面，ActivityStarter在计算完源activty栈，目标activty栈和启动模式后，把后续的启动流程交给RootWindowContainer了。在resumeFocusedStacksTopActivities方法里面继续启动流程。resumeFocusedStacksTopActivities这个方法我自己的理解是恢复当前正在聚焦的stack顶部的activity，也就是把我们的activity压到栈顶。

    // RootWindowContainer是窗口容器（WindowContainer）的根容器，管理了所有窗口容器，
    // 设备上所有的窗口（Window）、显示（Display）都是由它来管理的。
    // resumeFocusedStacksTopActivities会恢复对应任务栈顶部的Activity。这个方法会检查一些可见性相关的属性
    // 如果当前需要resume的activityStack 是可见的，这个时候才resume. 而可见性是由RootWindowContainer中的窗口控制的。
    boolean resumeFocusedStacksTopActivities(
            ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
            ......  
            result |= focusedStack.resumeTopActivityUncheckedLocked(target, targetOptions);
            ......  
    }

ActivityStack执行ActivtyA的onPase方法，再把启动流程交给ActivityStackSupervisor

在之前解析参数的步骤中已经创建好了ActivityRecord，接下来就是栈去管理和启动ActivityRecord的过程了。由RootWindowContainer调用到ActivityStack的resumeTopActivityInnerLocked方法，这个方法基于栈里面的各种情况去管理启动流程

    @GuardedBy("mService")
    private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
        ......
        //要启动的Activity
        ActivityRecord next = topRunningActivity(true /* focusableOnly */);  
        ......
       // 停止当前的Activity
        if (mResumedActivity != null) {
            if (DEBUG_STATES) Slog.d(TAG_STATES,
                    "resumeTopActivityLocked: Pausing " + mResumedActivity);
            pausing |= startPausingLocked(userLeaving, false /* uiSleeping */, next);// 停止当前的Activity
        }

        //next 就是要启动的这个ActivityRecord,它是一个全新的ActivityRecord，所以这个地方返回值是 false
        //我们到目前为止只是创建了一个ActivityRecord，还没有和进程关联起来
        if (next.attachedToProcess()) {  //为false
            ......
        }else{
           ......
           //启动指定的Activity
            mStackSupervisor.startSpecificActivity(next, true, true);
        }
        
    }

在这个函数里面根据栈里面的各种情况去管理启动流程，然后执行源Activity的onPase方法，把onPase包装成一个事务，让源Activity处于可见但不可交互状态;接下来就会走到ActivityStackSupervisor里面的startSpecificActivity方法

ActivityStackSupervisor把要启动的Activity的起始生命周期和结束生命周期封装在ClientTranstion事务中

ActivityStackSupervisor用于管理ActivityStack，ActivityStackSupervisor会将Activity生命周期封装成一个ClientTranstion事务

void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) {
         ......
		// 进程已经创建的话，直接启动activity
        if (wpc != null && wpc.hasThread()) {
            try {
                realStartActivityLocked(r, wpc, andResume, checkConfig);
        ......
		//进程不存在的话，为app启动一个进程
        mService.startProcessAsync(r, knownToBeDead, isTop, isTop ? "top-activity" : "activity");
    }

可以看到代码来到之前分析过的Application启动流程，如果activity所在的进程未创建过，就通过ZygoteProcess发送socket信息通知zygote去fork出app进程，如果进程已经被创建了，则会走realStartActivityLocked方法区真正启动Activity。

boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
            boolean andResume, boolean checkConfig) throws RemoteException {
            ......
/**主要包含两个内容： 一个是 要处理的一系列的生命周期事件，还有一个是这个Client在直线完这一系列事件后最终的lifecycle状态
一系列的事件是由callback 的列表控制，而最终的lifecycle状态则由mLifecycleStateRequest 控制*/
                // Create activity launch transaction.
                // 创建 clientTransaction 对象
                final ClientTransaction clientTransaction = ClientTransaction.obtain(
                        proc.getThread(), r.appToken);

                final DisplayContent dc = r.getDisplay().mDisplayContent;
                // 添加LaunchActivityItem
                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, proc.getReportedProcState(),
                        r.getSavedState(), r.getPersistentSavedState(), results, newIntents,
                        dc.isNextTransitionForward(), proc.createProfilerInfoIfNeeded(),
                        r.assistToken, r.createFixedRotationAdjustmentsIfNeeded()));

                // Set desired final state.
                final ActivityLifecycleItem lifecycleItem;
                if (andResume) {
					//需要Rusume的话，设置ResumeActivityItem到clientTransaction中
					lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward());
                } else {
                    lifecycleItem = PauseActivityItem.obtain();
                }
                clientTransaction.setLifecycleStateRequest(lifecycleItem);

                // Schedule transaction.
                // 获取生命周期管理类 ClientLifecycleManager，并执行事务
                mService.getLifecycleManager().scheduleTransaction(clientTransaction);
                ......

ClientTransaction是什么？

/**
 主要包含两个内容： 一个是 要处理的一系列的生命周期事件，
 还有一个是这个Client在执行一系列事件后最终的lifecycle状态
一系列的事件是由callback 的列表控制，而最终的lifecycle状态则由mLifecycleStateRequest 控制
 */
public class ClientTransaction implements Parcelable, ObjectPoolItem {

    /** A list of individual callbacks to a client. */
    @UnsupportedAppUsage
    //生命周期的一系列的函数
    private List<ClientTransactionItem> mActivityCallbacks;

    /**
     * Final lifecycle state in which the client activity should be after the transaction is
     * executed.
     */
     //执行完一系列生命周期后，最终的生命周期的状态
    private ActivityLifecycleItem mLifecycleStateRequest;

    /** Target client. */
    //目标进程
    private IApplicationThread mClient;

    /** Target client activity. Might be null if the entire transaction is targeting an app. */
    //目标进程对应的Binder
    private IBinder mActivityToken;
    ......

    // 通过 mClient 也就是IApplicationThread跨进程调用到应用进程
    public void schedule() throws RemoteException {
        mClient.scheduleTransaction(this);
    }

    private ClientTransaction() {}

    /** Obtain an instance initialized with provided params. */
    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;
    }
    ......

ClientTransaction里面有一个List，这个列表里面存储的是AMS希望App里面的Activity执行的生命周期事件的集合，ActivityLifecycleItem是AMS希望App执行完所有生命周期后，最终的生命周期状态。还有一个IApplicationThread 代表目标进程，IBinder 标识目标进程对应的binder。
ClientTransaction必须要实现Parcelable接口，ClientTransaction里面包含AMS希望App进程的Activity执行的生命周期事件的集合，这些生命周期事件会通过AMS和App进程跨进程通信，把ClientTransaction传递给App进程，最后由App进程执行这些Activity的生命周期事件。

AMS把希望要启动的Activity所执行的生命周期，执行完生命周期后的最终生命周期状态，Activty所在的进程，所在进程的Binder都封装成了一个ClientTransaction。

我们来看一下是怎么封装的。

// 添加LaunchActivityItem
                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, proc.getReportedProcState(),
                        r.getSavedState(), r.getPersistentSavedState(), results, newIntents,
                        dc.isNextTransitionForward(), proc.createProfilerInfoIfNeeded(),
                        r.assistToken, r.createFixedRotationAdjustmentsIfNeeded()));
                        
              if (andResume) {
					//需要Rusume的话，设置ResumeActivityItem到clientTransaction中
					lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward());
                } else {
                    lifecycleItem = PauseActivityItem.obtain();
                }
                clientTransaction.setLifecycleStateRequest(lifecycleItem);
               //获取生命周期管理类 ClientLifecycleManager，并执行事务
               mService.getLifecycleManager().scheduleTransaction(clientTransaction);

谷歌工程师先把LaunchActivityItem生命周期事件塞到clientTransaction里面，然后谷歌工程师认为启动activity应该在onresume生命周期终止，所以把ResumeActivityItem生命周期事件赋值给clientTransaction的mLifecycleStateRequest成为最终的生命周期状态。最后通过ClientLifecycleManager生命周期管理类把我们封装好的生命周期事务从AMS所在的进程System_service传递到App进程。

ClientTransaction在AMS和App之间的通信 ClientLifecycleManager是啥？

class ClientLifecycleManager {
    // TODO(lifecycler): Implement building transactions or global transaction.
    // TODO(lifecycler): Use object pools for transactions and transaction items.

    /**
     * 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();
        }
    }
    ......

代码贴出来一看，就是管理ClientTransaction，对ClientTransaction 做了一层封装，方便AMS调用ClientTransaction。scheduleTransaction方法最后会执行到ClientTransaction的schedule方法，最后通过ClientTransaction里面的App的Binder进行跨进程通信，把ClientTransaction给发出去。这里的Binder是ActivityThread的attach方法传递过来的。

 // 通过 mClient 也就是IApplicationThread跨进程调用到应用进程
    public void schedule() throws RemoteException {
        mClient.scheduleTransaction(this);
    }

最后跑到ActivityThread里面执行scheduleTransaction方法

        @Override
        public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
            ActivityThread.this.scheduleTransaction(transaction);
        }

ActivityThread是继承ClientTransactionHandler，最后会执行这个抽象类里面的scheduleTransaction方法

public abstract class ClientTransactionHandler {

    // Schedule phase related logic and handlers.

    /** Prepare and schedule transaction for execution. */
    void scheduleTransaction(ClientTransaction transaction) {
        transaction.preExecute(this);
        sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
    }
    ......

ClientTransactionHandler 的scheduleTransaction通过sendMessage发送一个message消息到主线程，最后回到ActivityThread里面

                   final ClientTransaction transaction = (ClientTransaction) msg.obj;
                   //TransactionExecutor
                    mTransactionExecutor.execute(transaction);
                    if (isSystem()) {
                        // Client transactions inside system process are recycled on the client side
                        // instead of ClientLifecycleManager to avoid being cleared before this
                        // message is handled.
                        transaction.recycle();
                    }

至此完成了AMS到App进程的跨进程通信，然后由Binder线程池里面的子线程切换到主线程。