Android P ActivityManagerService（七） TransactionExecutor消息机制

TransactionExecutor，在Activity启动代码的初期就有接触过；最后realStartActivityLocked中也有涉及；

初看的时候会有些模糊；决定先整理一下TransactionExecutor相关的知识，既能熟悉源码，也能对自己的编码有所启示；

主要相关代码都在frameworks\base\core\java\android\app\servertransaction文件夹下；

TransactionExecutor

官方注释：一个管理实务在正确顺序执行的类；

/**
 * Class that manages transaction execution in the correct order.
 * @hide
 */
public class TransactionExecutor

它的一个重要方法是execute；

通过execute执行实务；分3步，首先，执行callbacks；再次，执行lifecycle；最后，清理mPendingActions；

/**
 * Resolve transaction.
 * First all callbacks will be executed in the order they appear in the list. If a callback
 * requires a certain pre- or post-execution state, the client will be transitioned accordingly.
 * Then the client will cycle to the final lifecycle state if provided. Otherwise, it will
 * either remain in the initial state, or last state needed by a callback.
 */
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");
}

TransactionExecutor还持有ClientTransactionHandler对象；ClientTransactionHandler是任务的真正执行者；

在TransactionExecutor的构造函数中ClientTransactionHandler作为参数传入；

private ClientTransactionHandler mTransactionHandler;
private PendingTransactionActions mPendingActions = new PendingTransactionActions();
private TransactionExecutorHelper mHelper = new TransactionExecutorHelper();

/** Initialize an instance with transaction handler, that will execute all requested actions. */
public TransactionExecutor(ClientTransactionHandler clientTransactionHandler) {
    mTransactionHandler = clientTransactionHandler;
}

ClientTransaction

它是TransactionExecutor.execute的参数；

官方注释：它个容器，包含了一组消息和一个lifecycle；

消息：ClientTransactionItem；

lifecycle：ActivityLifecycleItem；

它还有两个成员：IApplicationThread mClient和IBinder mActivityToken；

IApplicationThread mClient是对应ActiviyThread中的内部类ApplicationThread；之前就提到过ApplicationThread实现了IApplicationThread.Stub用以进程间通讯；

IBinder mActivityToken是Activity的token；

/**
 * A container that holds a sequence of messages, which may be sent to a client.
 * This includes a list of callbacks and a final lifecycle state.
 *
 * @see com.android.server.am.ClientLifecycleManager
 * @see ClientTransactionItem
 * @see ActivityLifecycleItem
 * @hide
 */
public class ClientTransaction implements Parcelable, ObjectPoolItem 

获取实例，obtain方法，两个参数分别是之前提到的IApplicationThread和activityToken：

/** 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有两个重要方法，添加消息和设置Lifecycle；

添加消息：消息存放在一个List中，直接add就可以了；

/**
 * Add a message to the end of the sequence of callbacks.
 * @param activityCallback A single message that can contain a lifecycle request/callback.
 */
public void addCallback(ClientTransactionItem activityCallback) {
    if (mActivityCallbacks == null) {
        mActivityCallbacks = new ArrayList<>();
    }
    mActivityCallbacks.add(activityCallback);
}

设置Lifecycle：

/**
 * Set the lifecycle state in which the client should be after executing the transaction.
 * @param stateRequest A lifecycle request initialized with right parameters.
 */
public void setLifecycleStateRequest(ActivityLifecycleItem stateRequest) {
    mLifecycleStateRequest = stateRequest;
}

ClientTransactionItem

消息对象；是一个抽象类；也就是说实际使用时，需要被继承；

官方注释：一个callback消息；可能是Activity configuration change或者multi-window mode change等；

/**
 * A callback message to a client that can be scheduled and executed.
 * Examples of these might be activity configuration change, multi-window mode change, activity
 * result delivery etc.
 *
 * @see ClientTransaction
 * @see com.android.server.am.ClientLifecycleManager
 * @hide
 */
public abstract class ClientTransactionItem implements BaseClientRequest, Parcelable {

    /** Get the state that must follow this callback. */
    @LifecycleState
    public int getPostExecutionState() {
        return UNDEFINED;
    }


    // Parcelable

    @Override
    public int describeContents() {
        return 0;
    }
}

它实现了两个接口，BaseClientRequest和Parcelable；其中Parcelable是序列化，这个不做展开；

BaseClientRequest有三个需要被实现的方法，preExecute、execute和postExecute；

/**
 * Base interface for individual requests from server to client.
 * Each of them can be prepared before scheduling and, eventually, executed.
 * @hide
 */
public interface BaseClientRequest extends ObjectPoolItem {

    /**
     * Prepare the client request before scheduling.
     * An example of this might be informing about pending updates for some values.
     *
     * @param client Target client handler.
     * @param token  Target activity token.
     */
    default void preExecute(ClientTransactionHandler client, IBinder token) {
    }

    /**
     * Execute the request.
     * @param client Target client handler.
     * @param token Target activity token.
     * @param pendingActions Container that may have data pending to be used.
     */
    void execute(ClientTransactionHandler client, IBinder token,
            PendingTransactionActions pendingActions);

    /**
     * Perform all actions that need to happen after execution, e.g. report the result to server.
     * @param client Target client handler.
     * @param token Target activity token.
     * @param pendingActions Container that may have data pending to be used.
     */
    default void postExecute(ClientTransactionHandler client, IBinder token,
            PendingTransactionActions pendingActions) {
    }
}

继承ClientTransactionItem的类；

ActivityLifecycleItem	Lifecycle的抽象类；这个后面再细看；
ActivityConfigurationChangeItem	Activity Configuration Changed消息；
ActivityResultItem	Activity Result消息；
ConfigurationChangeItem	App configuration change消息；
MoveToDisplayItem	Activity move to a different display消息；
MultiWindowModeChangeItem	Multi-window mode change消息；
PipModeChangeItem	Picture in picture mode change消息；
WindowVisibilityItem	Window visibility change消息；
NewIntentItem	New intent消息；
ActivityRelaunchItem	Activity relaunch callback消息；
LaunchActivityItem	Request to launch an activity；

看一下之前提到过的ActivityResultItem；

唯一的成员变量是ResultInfo列表；

主要方法是：execute和obtain；

execute用执行任务，参数是ClientTransactionHandler 、IBinder和PendingTransactionActions；其中ClientTransactionHandler 是真正执行任务的对象；

obtain用于获得ActivityResultItem对象，参数是ResultInfo列表；

/**
 * Activity result delivery callback.
 * @hide
 */
public class ActivityResultItem extends ClientTransactionItem {

    private List<ResultInfo> mResultInfoList;

    /* TODO(b/78294732)
    @Override
    public int getPostExecutionState() {
        return ON_RESUME;
    }*/

    @Override
    public void execute(ClientTransactionHandler client, IBinder token,
            PendingTransactionActions pendingActions) {
        Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityDeliverResult");
        client.handleSendResult(token, mResultInfoList, "ACTIVITY_RESULT");
        Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
    }


    // ObjectPoolItem implementation

    private ActivityResultItem() {}

    /** Obtain an instance initialized with provided params. */
    public static ActivityResultItem obtain(List<ResultInfo> resultInfoList) {
        ActivityResultItem instance = ObjectPool.obtain(ActivityResultItem.class);
        if (instance == null) {
            instance = new ActivityResultItem();
        }
        instance.mResultInfoList = resultInfoList;

        return instance;
    }

    //...
}

ClientTransactionHandler

它和其他文件不同，在frameworks\base\core\java\android\app下；

他是一个抽象类；也就是说需要有人继承；

在之前的案例中，ActivityThread继承了这个抽象类；

/**
 * Defines operations that a {@link android.app.servertransaction.ClientTransaction} or its items
 * can perform on client.
 * @hide
 */
public abstract class ClientTransactionHandler

ActivityLifecycleItem

这是一个抽象类，继承他的都是一些代码生命周期的类；

/**
 * Request for lifecycle state that an activity should reach.
 * @hide
 */
public abstract class ActivityLifecycleItem extends ClientTransactionItem

继承ActivityLifecycleItem的类有：

DestroyActivityItem	请求销毁Activity
StopActivityItem	请求使一个Activity进入Stop状态
PauseActivityItem	请求使一个Activity进入Pause状态
ResumeActivityItem	请求使一个Activity进入Resume状态

这里看一下之前提到过的ResumeActivityItem；

它这里最大的不同是在方法postExecute中；直接调用了AMS的方法ActivityManager.getService().activityResumed(token);

/**
 * Request to move an activity to resumed state.
 * @hide
 */
public class ResumeActivityItem extends ActivityLifecycleItem {

    private static final String TAG = "ResumeActivityItem";

    private int mProcState;
    private boolean mUpdateProcState;
    private boolean mIsForward;

    @Override
    public void preExecute(ClientTransactionHandler client, IBinder token) {
        if (mUpdateProcState) {
            client.updateProcessState(mProcState, false);
        }
    }

    @Override
    public void execute(ClientTransactionHandler client, IBinder token,
            PendingTransactionActions pendingActions) {
        Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityResume");
        client.handleResumeActivity(token, true /* finalStateRequest */, mIsForward,
                "RESUME_ACTIVITY");
        Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
    }

    @Override
    public void postExecute(ClientTransactionHandler client, IBinder token,
            PendingTransactionActions pendingActions) {
        try {
            // TODO(lifecycler): Use interface callback instead of AMS.
            ActivityManager.getService().activityResumed(token);
        } catch (RemoteException ex) {
            throw ex.rethrowFromSystemServer();
        }
    }
    //...
}

 

小结

• ActivityThread继承了ClientTransactionHandler；是消息真正执行者；