深入理解 ClientLifecycleManager 机制

最新推荐文章于 2023-03-03 07:00:00 发布

Big Skipper

最新推荐文章于 2023-03-03 07:00:00 发布

阅读量1.3k

点赞数 4

分类专栏： Android framework

本文链接：https://blog.csdn.net/liuwg1226/article/details/116063863

版权

Android framework 专栏收录该内容

94 篇文章 122 订阅

订阅专栏

一　概述

ClientLifecycleManager 是管理 Activity 生命周期的，在 ActivityTaskManagerService 里面提供 getLifecycleManager 来获取此对象，其中 mLifecycleManager 是在 ActivityTaskManagerService 的构造方法里面初始化的。

ActivityTaskManagerService.java

public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
    ......
    private final ClientLifecycleManager mLifecycleManager;
    ......
    public ActivityTaskManagerService(Context context) {
        mContext = context;
        mFactoryTest = FactoryTest.getMode();
        mSystemThread = ActivityThread.currentActivityThread();
        mUiContext = mSystemThread.getSystemUiContext();
        mLifecycleManager = new ClientLifecycleManager();//mLifecycleManager初始化
        mInternal = new LocalService();
        GL_ES_VERSION = SystemProperties.getInt("ro.opengles.version", GL_ES_VERSION_UNDEFINED);
    }
    ......
    //获取mLifecycleManager对象
    ClientLifecycleManager getLifecycleManager() {
        return mLifecycleManager;
    }
    ......
}

ClientLifecycleManager 机制涉及到的整体类图如下：
在这里插入图片描述
相关类功能说明：

ClientTransactionItem 对象，一个回调消息，client 端可以调用执行，实现了 BaseClientRequest 接口，在接口里面定义了3个方法：preExecute，execute，poseExecute
ActivityLifecycleItem 继承自 ClientTransctionItem，主要的子类有 ResumeActivityItem、PauseActivityItem、StopActivityItem、DestoryActivityItem
ClientTransaction 是一个容器，持有一系列可以发送给 client 的消息，包括有 mActivityCallbacks 列表和一个目标状态 mLifecycleStateRequest
TransactionExecutor 用来执行 ClientTransaction，定义在 ActivityThread 应用端

接下来我们对涉及到的组件进行分析，然后用一个例子来说明其中的调用流程。

二　ClientTransactionItem

2.1 ClientTransactionItem.java

public abstract class ClientTransactionItem implements BaseClientRequest, Parcelable {

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

ClientTransactionItem 实现了 Parcelable 接口，可以被用于进程间传递，同时实现了 BaseClientRequest 接口，如下：

BaseClientRequest.java

public interface BaseClientRequest extends ObjectPoolItem {

    
    default void preExecute(ClientTransactionHandler client, IBinder token) {
    }

    void execute(ClientTransactionHandler client, IBinder token,
            PendingTransactionActions pendingActions);

    
    default void postExecute(ClientTransactionHandler client, IBinder token,
            PendingTransactionActions pendingActions) {
    }
}

有很多类继承了 ClientTransactionItem 类，用来实现具体的业务逻辑，注意 execute 函数中的 client 参数，它是 ClientTransactionHandler 类型的，这里传入的就是 ActivityThread，我们知道 ActivityThread 是 ClientTransactionHandler 的唯一实现类。

我们来看继承并实现 ClientTransactionItem 的类有哪些：

LaunchActivityItem
ActivityLifecycleItem
ConfigurationChangeItem
PipModeChangeItem
ActivityResultItem
…

其中我们需要重点关注的是 LaunchActivityItem 和 ActivityLifecycleItem，其中 ActivityLifecycleItem 是一个抽象类，还有 ResumeActivityItem，PauseActivityItem，StopActivityItem，DestroyActivityItem 四个类继承实现了 ActivityLifecycleItem，用来实现对 Activity 生命周期的调度。

LaunchActivityItem.java

public class LaunchActivityItem extends ClientTransactionItem {
    ......
    @Override
    public void preExecute(ClientTransactionHandler client, IBinder token) {
        ......
    }

    @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, mAssistToken);
        //关键点：调用 client.handleLaunchActivity，我们知道 client 也就是 ActivityThread
        client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
        Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
    }

    @Override
    public void postExecute(ClientTransactionHandler client, IBinder token,
            PendingTransactionActions pendingActions) {
        client.countLaunchingActivities(-1);
    }
    ......
}

ActivityLifecycleItem.java

public abstract class ActivityLifecycleItem extends ClientTransactionItem {

    @IntDef(prefix = { "UNDEFINED", "PRE_", "ON_" }, value = {
            UNDEFINED,
            PRE_ON_CREATE,
            ON_CREATE,
            ON_START,
            ON_RESUME,
            ON_PAUSE,
            ON_STOP,
            ON_DESTROY,
            ON_RESTART
    })
    @Retention(RetentionPolicy.SOURCE)
    public @interface LifecycleState{}
    public static final int UNDEFINED = -1;
    public static final int PRE_ON_CREATE = 0;
    public static final int ON_CREATE = 1;
    public static final int ON_START = 2;
    public static final int ON_RESUME = 3;
    public static final int ON_PAUSE = 4;
    public static final int ON_STOP = 5;
    public static final int ON_DESTROY = 6;
    public static final int ON_RESTART = 7;

    /** A final lifecycle state that an activity should reach. */
    @LifecycleState
    public abstract int getTargetState();

    /** Called by subclasses to make sure base implementation is cleaned up */
    @Override
    public void recycle() {
    }
}

ResumeActivityItem.java

public class ResumeActivityItem extends ActivityLifecycleItem {

    private static final String TAG = "ResumeActivityItem";
    ......
    @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，我们知道 client 也就是 ActivityThread
        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.
            ActivityTaskManager.getService().activityResumed(token);
        } catch (RemoteException ex) {
            throw ex.rethrowFromSystemServer();
        }
    }

    @Override
    public int getTargetState() {
        return ON_RESUME;
    }
    ......
}

其它的几个 Item 类就不再赘述了，都是通过调用 ActivityThread 的相关函数实现对 Activity 生命周期函数的调用。

三　ClientTransaction

ClientTransaction.java

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. */
    private IBinder mActivityToken;

    /** Get the target client of the transaction. */
    public IApplicationThread getClient() {
        return mClient;
    }

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

    /** Get the list of callbacks. */
    @Nullable
    @UnsupportedAppUsage
    List<ClientTransactionItem> getCallbacks() {
        return mActivityCallbacks;
    }

    /** Get the target activity. */
    @Nullable
    @UnsupportedAppUsage
    public IBinder getActivityToken() {
        return mActivityToken;
    }

    /** Get the target state lifecycle request. */
    @VisibleForTesting
    @UnsupportedAppUsage
    public ActivityLifecycleItem getLifecycleStateRequest() {
        return mLifecycleStateRequest;
    }

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

    /**
     * Do what needs to be done while the transaction is being scheduled on the client side.
     * @param clientTransactionHandler Handler on the client side that will executed all operations
     *                                 requested by transaction items.
     */
    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);
        }
    }

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


    // ObjectPoolItem implementation

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

    // Parcelable implementation

    /** Write to Parcel. */
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeStrongBinder(mClient.asBinder());
        final boolean writeActivityToken = mActivityToken != null;
        dest.writeBoolean(writeActivityToken);
        if (writeActivityToken) {
            dest.writeStrongBinder(mActivityToken);
        }
        dest.writeParcelable(mLifecycleStateRequest, flags);
        final boolean writeActivityCallbacks = mActivityCallbacks != null;
        dest.writeBoolean(writeActivityCallbacks);
        if (writeActivityCallbacks) {
            dest.writeParcelableList(mActivityCallbacks, flags);
        }
    }

    /** Read from Parcel. */
    private ClientTransaction(Parcel in) {
        mClient = (IApplicationThread) in.readStrongBinder();
        final boolean readActivityToken = in.readBoolean();
        if (readActivityToken) {
            mActivityToken = in.readStrongBinder();
        }
        mLifecycleStateRequest = in.readParcelable(getClass().getClassLoader());
        final boolean readActivityCallbacks = in.readBoolean();
        if (readActivityCallbacks) {
            mActivityCallbacks = new ArrayList<>();
            in.readParcelableList(mActivityCallbacks, getClass().getClassLoader());
        }
    }
    ......
}

ClientTransaction 属性有个 mClient 通过这个属性与应用进程进行通信，主要是调用 ClientTransaction 的 schedule 方法，它其中还包含了 ClientTransactionItem 列表 mActivityCallbacks 和一个 ActivityLifecycleItem 类型的 mLifecycleStateRequest。

四　TransactionExecutor

public class TransactionExecutor {
    ......
    private ClientTransactionHandler mTransactionHandler;
    private PendingTransactionActions mPendingActions = new PendingTransactionActions();
    private TransactionExecutorHelper mHelper = new TransactionExecutorHelper();

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

    public void execute(ClientTransaction transaction) {
        final IBinder token = transaction.getActivityToken();
        if (token != null) {
            final Map<IBinder, ClientTransactionItem> activitiesToBeDestroyed =
                    mTransactionHandler.getActivitiesToBeDestroyed();
            final ClientTransactionItem destroyItem = activitiesToBeDestroyed.get(token);
            if (destroyItem != null) {
                if (transaction.getLifecycleStateRequest() == destroyItem) {
                    // It is going to execute the transaction that will destroy activity with the
                    // token, so the corresponding to-be-destroyed record can be removed.
                    activitiesToBeDestroyed.remove(token);
                }
                if (mTransactionHandler.getActivityClient(token) == null) {
                    // The activity has not been created but has been requested to destroy, so all
                    // transactions for the token are just like being cancelled.
                    Slog.w(TAG, tId(transaction) + "Skip pre-destroyed transaction:\n"
                            + transactionToString(transaction, mTransactionHandler));
                    return;
                }
            }
        }
        executeCallbacks(transaction);//执行 ClientTransaction 的 mActivityCallbacks

        executeLifecycleState(transaction);//执行 ClientTransaction 的 mLifecycleStateRequest
        mPendingActions.clear();
    }

    @VisibleForTesting
    public void executeCallbacks(ClientTransaction transaction) {
        final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
        ......
        final IBinder token = transaction.getActivityToken();
        ActivityClientRecord r = mTransactionHandler.getActivityClient(token);

        final ActivityLifecycleItem finalStateRequest = transaction.getLifecycleStateRequest();
        final int finalState = finalStateRequest != null ? finalStateRequest.getTargetState()
                : UNDEFINED;
        // Index of the last callback that requests some post-execution state.
        final int lastCallbackRequestingState = lastCallbackRequestingState(transaction);

        final int size = callbacks.size();
        for (int i = 0; i < size; ++i) {//遍历callbacks
            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, transaction);
            }

            //执行每个 ClientTransactionItem 的 execute 方法
            item.execute(mTransactionHandler, token, mPendingActions);
            item.postExecute(mTransactionHandler, token, mPendingActions);
            if (r == null) {
                // Launch activity request will create an activity record.
                r = mTransactionHandler.getActivityClient(token);
            }

            if (postExecutionState != UNDEFINED && r != null) {
                // Skip the very last transition and perform it by explicit state request instead.
                final boolean shouldExcludeLastTransition =
                        i == lastCallbackRequestingState && finalState == postExecutionState;
                cycleToPath(r, postExecutionState, shouldExcludeLastTransition, transaction);
            }
        }
    }

    /** Transition to the final state if requested by the transaction. */
    private void executeLifecycleState(ClientTransaction transaction) {
        final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
        if (lifecycleItem == null) {
            // No lifecycle request, return early.
            return;
        }

        final IBinder token = transaction.getActivityToken();
        final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
        if (DEBUG_RESOLVER) {
            Slog.d(TAG, tId(transaction) + "Resolving lifecycle state: "
                    + lifecycleItem + " for activity: "
                    + getShortActivityName(token, mTransactionHandler));
        }

        if (r == null) {
            // Ignore requests for non-existent client records for now.
            return;
        }

        // Cycle to the state right before the final requested state.
        cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */, transaction);

        // Execute the final transition with proper parameters.
        lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
        lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
    }

    /** Transition the client between states. */
    @VisibleForTesting
    public void cycleToPath(ActivityClientRecord r, int finish, ClientTransaction transaction) {
        cycleToPath(r, finish, false /* excludeLastState */, transaction);
    }

    private void cycleToPath(ActivityClientRecord r, int finish, boolean excludeLastState,
            ClientTransaction transaction) {
        final int start = r.getLifecycleState();
        if (DEBUG_RESOLVER) {
            Slog.d(TAG, tId(transaction) + "Cycle activity: "
                    + getShortActivityName(r.token, mTransactionHandler)
                    + " from: " + getStateName(start) + " to: " + getStateName(finish)
                    + " excludeLastState: " + excludeLastState);
        }
        final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
        performLifecycleSequence(r, path, transaction);
    }

    /** Transition the client through previously initialized state sequence. */
    private void performLifecycleSequence(ActivityClientRecord r, IntArray path,
            ClientTransaction transaction) {
        final int size = path.size();
        for (int i = 0, state; i < size; i++) {
            state = path.get(i);
            if (DEBUG_RESOLVER) {
                Slog.d(TAG, tId(transaction) + "Transitioning activity: "
                        + getShortActivityName(r.token, mTransactionHandler)
                        + " to state: " + getStateName(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);
            }
        }
    }
}

五　实例分析

我们从启动 Activity 的 ActivityStackSupervisor 的 realStartActivityLocked() 方法分析起。

ActivityStackSupervisor.java

boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
		boolean andResume, boolean checkConfig) throws RemoteException {
	......
	final TaskRecord task = r.getTaskRecord();
	final ActivityStack stack = task.getStack();

	beginDeferResume();

	try {
		......
		try {
			......
			// 关键点：创建 ClientTransaction
			final ClientTransaction clientTransaction = ClientTransaction.obtain(
					proc.getThread(), r.appToken);

			final DisplayContent dc = r.getDisplay().mDisplayContent;
			// 给 clientTransaction 添加 LaunchActivityItem 形式的 CallBack
			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.icicle, r.persistentState, results, newIntents,
					dc.isNextTransitionForward(), proc.createProfilerInfoIfNeeded(),
							r.assistToken));

			// 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,并调用其scheduleTransaction,执行clientTransaction
			mService.getLifecycleManager().scheduleTransaction(clientTransaction);
			......
		} catch (RemoteException e) {
			......
		}
	} finally {
		endDeferResume();
	}
	......
	return true;
}

在这个方法中，会创建一个 ClientTransaction 对象，它会被传递到客户进程，同时给 ClientTransaction 实例添加 LaunchActivityItem 形式的 CallBack 和设置 setLifecycleStateRequest，我们来看一下 addCallback 的 LaunchActivityItem 的 obtain() 方法。

LaunchActivityItem.java

public static LaunchActivityItem obtain(Intent intent, int ident, ActivityInfo info,
        Configuration curConfig, Configuration overrideConfig, CompatibilityInfo compatInfo,
        String referrer, IVoiceInteractor voiceInteractor, int procState, Bundle state,
        PersistableBundle persistentState, List<ResultInfo> pendingResults,
        List<ReferrerIntent> pendingNewIntents, boolean isForward, ProfilerInfo profilerInfo,
        IBinder assistToken) {
    LaunchActivityItem instance = ObjectPool.obtain(LaunchActivityItem.class);
    if (instance == null) {
        instance = new LaunchActivityItem();
    }
    setValues(instance, intent, ident, info, curConfig, overrideConfig, compatInfo, referrer,
            voiceInteractor, procState, state, persistentState, pendingResults,
            pendingNewIntents, isForward, profilerInfo, assistToken);

    return instance;
}

创建了一个 LaunchActivityItem 实例，并对参数进行了一些赋值操作。回到上面看一下 ClientTransaction 的 addCallback 方法，传入的参数就是这个 LaunchActivityItem 实例。

ClientTransaction.java

private List<ClientTransactionItem> mActivityCallbacks;
......
public void addCallback(ClientTransactionItem activityCallback) {
    if (mActivityCallbacks == null) {
        mActivityCallbacks = new ArrayList<>();
    }
    mActivityCallbacks.add(activityCallback);
}

将这个 LaunchActivityItem 保存在了 mActivityCallbacks 数组中。回到 realStartActivityLocked() 方法。为 ClientTransaction 添加 mActivityCallback 后，同时会调用 setLifecycleStateRequest 方法对 ClientTransaction 对象的 mLifecycleStateRequest 属性进行赋值。这里会创建一个 ResumeActivityItem 对象添加到 mLifecycleStateRequest 中去。

我们再捋一下，这个 ClientTransaction 对象包含了与客户端通信的 IApplicationThread、token，并且还包括了一个存有 LaunchActivityItem 对象的 callback 和一个存有 ResumeActivityItem 对象的 mLifecycleStateRequest 变量。接着继续执行了 mService.getLifecycleManager().scheduleTransaction() 方法。

ClientLifecycleManager.java

void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
    final IApplicationThread client = transaction.getClient();
    transaction.schedule();//执行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.java

public void schedule() throws RemoteException {
    mClient.scheduleTransaction(this);
}

调用了 mClient 的 scheduleTransaction 方法，并传入了 this，这个 this 就是这个经过我们填充的 ClientTransaction 对象本身。而 mClient 为传入的 IApplicationThread 对象，所以最终会在应用进程中调用 ApplicationThread 的 scheduleTransaction 方法。

ActivityThread.java

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

调用 ActivityThread 的 scheduleTransaction() 方法。ActivityThread 继承自 ClientTransactionHandler，实际调用的是 ClientTransactionHandler 的 scheduleTransaction() 方法，传入了创建好的 transaction 对象。

ClientTransactionHandler.java

void scheduleTransaction(ClientTransaction transaction) {
    transaction.preExecute(this);
    sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}

调用 sendMessage 方法，这里通过 Handler 发送了一个 EXECUTE_TRANSACTION 消息，会交给 ActivityThread 的 H 类来处理。

ActivityThread.java::H

private final TransactionExecutor mTransactionExecutor = new TransactionExecutor(this);
......
class H extends Handler {
	......
	public void handleMessage(Message msg) {
		......
		switch (msg.what) {
			......
			case EXECUTE_TRANSACTION:
				final ClientTransaction transaction = (ClientTransaction) msg.obj;
				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();
				}
				// TODO(lifecycler): Recycle locally scheduled transactions.
				break;
			......
		}
		......
	}
}

在 handleMessage() 回调方法中执行 EXECUTE_TRANSACTION 对应的 case。首先取出 ClientTransaction 对象，然后调用 mTransactionExecutor 的 execute 方法。mTransactionExecutor 是一个 TransactionExecutor 对象。从类的命名也可以看出，TransactionExecutor 这个类的作用是用来处理 Transaction 的。

TransactionExecutor.java

public void execute(ClientTransaction transaction) {
    if (DEBUG_RESOLVER) Slog.d(TAG, tId(transaction) + "Start resolving transaction");

    final IBinder token = transaction.getActivityToken();
    ......

    executeCallbacks(transaction);

    executeLifecycleState(transaction);
    mPendingActions.clear();
    if (DEBUG_RESOLVER) Slog.d(TAG, tId(transaction) + "End resolving transaction");
}

会顺序调用 executeCallbacks() 和 executeLifecycleState 方法。

TransactionExecutor.java

public void executeCallbacks(ClientTransaction transaction) {
        final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
        if (callbacks == null || callbacks.isEmpty()) {
            // No callbacks to execute, return early.
            return;
        }
        if (DEBUG_RESOLVER) Slog.d(TAG, tId(transaction) + "Resolving callbacks in transaction");

        final IBinder token = transaction.getActivityToken();
        ActivityClientRecord r = mTransactionHandler.getActivityClient(token);

        // In case when post-execution state of the last callback matches the final state requested
        // for the activity in this transaction, we won't do the last transition here and do it when
        // moving to final state instead (because it may contain additional parameters from server).
        final ActivityLifecycleItem finalStateRequest = transaction.getLifecycleStateRequest();
        final int finalState = finalStateRequest != null ? finalStateRequest.getTargetState()
                : UNDEFINED;
        // Index of the last callback that requests some post-execution state.
        final int lastCallbackRequestingState = lastCallbackRequestingState(transaction);

        final int size = callbacks.size();
        //遍历callbacks数组
        for (int i = 0; i < size; ++i) {
            //从callbacks数组中取出item。
            final ClientTransactionItem item = callbacks.get(i);
            if (DEBUG_RESOLVER) Slog.d(TAG, tId(transaction) + "Resolving callback: " + item);
            final int postExecutionState = item.getPostExecutionState();
            final int closestPreExecutionState = mHelper.getClosestPreExecutionState(r,
                    item.getPostExecutionState());
            if (closestPreExecutionState != UNDEFINED) {
                cycleToPath(r, closestPreExecutionState, transaction);
            }
            //调用launchActivityItem的execute方法
            item.execute(mTransactionHandler, token, mPendingActions);
            item.postExecute(mTransactionHandler, token, mPendingActions);
            if (r == null) {
                // Launch activity request will create an activity record.
                r = mTransactionHandler.getActivityClient(token);
            }

            if (postExecutionState != UNDEFINED && r != null) {
                // Skip the very last transition and perform it by explicit state request instead.
                final boolean shouldExcludeLastTransition =
                        i == lastCallbackRequestingState && finalState == postExecutionState;
                cycleToPath(r, postExecutionState, shouldExcludeLastTransition, transaction);
            }
        }
    }

首先从系统进程传来的 ClientTransaction 中得到 mActivityCallbacks 列表。这个在前面 addcallback 的时候已经看了，里面保存了一个 LaunchActivityItem。接着通过遍历取出这个 LaunchActivityItem，接着调用了它的 execute() 方法，传入的第一个参数是持有的 ActivityThread 对象，第二个参数 token 是从系统进程传来的 activityToken。

LaunchActivityItem.java

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, mAssistToken);
    client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
    Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}

调用了 ActivityThread 类的 handleLaunchActivity() 方法。

ActivityThread.java

public Activity handleLaunchActivity(ActivityClientRecord r,
		PendingTransactionActions pendingActions, Intent customIntent) {
	......
	final Activity a = performLaunchActivity(r, customIntent);

	if (a != null) {
		r.createdConfig = new Configuration(mConfiguration);
		reportSizeConfigurations(r);
		if (!r.activity.mFinished && pendingActions != null) {
			pendingActions.setOldState(r.state);
			pendingActions.setRestoreInstanceState(true);
			pendingActions.setCallOnPostCreate(true);
		}
	} else {
		......
	}
	return a;
}

继续调用 performLaunchActivity() 方法。

ActivityThread.java

Instrumentation mInstrumentation;
......
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
	......
	ContextImpl appContext = createBaseContextForActivity(r);
	Activity activity = null;
	try {
		java.lang.ClassLoader cl = appContext.getClassLoader();
		//创建我们自己的Activity实例
		activity = mInstrumentation.newActivity(
				cl, component.getClassName(), r.intent);
		StrictMode.incrementExpectedActivityCount(activity.getClass());
		r.intent.setExtrasClassLoader(cl);
		r.intent.prepareToEnterProcess();
		if (r.state != null) {
			r.state.setClassLoader(cl);
		}
	} catch (Exception e) {
		...
	}

	try {
	    //尝试创建Application，其实前面已经创建过了。
		Application app = r.packageInfo.makeApplication(false, mInstrumentation);
		......
		if (activity != null) {
			CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
			Configuration config = new Configuration(mCompatConfiguration);
			if (r.overrideConfig != null) {
				config.updateFrom(r.overrideConfig);
			}
			if (DEBUG_CONFIGURATION) Slog.v(TAG, "Launching activity "
					+ r.activityInfo.name + " with config " + config);
			Window window = null;
			if (r.mPendingRemoveWindow != null && r.mPreserveWindow) {
				window = r.mPendingRemoveWindow;
				r.mPendingRemoveWindow = null;
				r.mPendingRemoveWindowManager = null;
			}
			appContext.setOuterContext(activity);
			//会在这个方法中创建Activity的PhoneWindow，并绑定对应的WindowManager。
			activity.attach(appContext, this, getInstrumentation(), r.token,
					r.ident, app, r.intent, r.activityInfo, title, r.parent,
					r.embeddedID, r.lastNonConfigurationInstances, config,
					r.referrer, r.voiceInteractor, window, r.configCallback,
					r.assistToken);

			...
			int theme = r.activityInfo.getThemeResource();
			if (theme != 0) {
				activity.setTheme(theme);
			}

			activity.mCalled = false;
			//执行我们新Activity的OnCreate生命周期。
			if (r.isPersistable()) {
				mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
			} else {
				mInstrumentation.callActivityOnCreate(activity, r.state);
			}
			......
		}
		r.setState(ON_CREATE);
		......
	} catch (SuperNotCalledException e) {
		throw e;

	} catch (Exception e) {
		...
	}
	return activity;
}

这个方法做了很多事，主要分4个部分来看。

首先是 Activity 实例的创建，这里的 Activity 指的是我们要启动的新的 XXXActivity。调用了 Instrumentation 类的 newActivity() 方法。
接下来会尝试创建 Application，r.packageInfo 返回的是 LoadedApk 对象，调用了 LoadedApk 的 makeApplication() 方法
LoadedApk.java

public Application makeApplication(boolean forceDefaultAppClass,
        Instrumentation instrumentation) {
    if (mApplication != null) {
        return mApplication;
    }
    ......
    return app;
}

这个方法很长，主要是创建应用的 Application 实例。但是因为之前在 bindApplication 时已经创建了 Application，所以这里在一开始 if 的时候直接返回了。

回到 performLaunchActivity() 方法，接着调用 Activity 类的 attach() 方法

Activity.java
final void attach(Context context, ActivityThread aThread,
        Instrumentation instr, IBinder token, int ident,
        Application application, Intent intent, ActivityInfo info,
        CharSequence title, Activity parent, String id,
        NonConfigurationInstances lastNonConfigurationInstances,
        Configuration config, String referrer, IVoiceInteractor voiceInteractor,
        Window window, ActivityConfigCallback activityConfigCallback, IBinder assistToken) {
    attachBaseContext(context);

    mFragments.attachHost(null /*parent*/);
    //创建PhoneWindow
    mWindow = new PhoneWindow(this, window, activityConfigCallback);
    mWindow.setWindowControllerCallback(this);
    mWindow.setCallback(this);
    mWindow.setOnWindowDismissedCallback(this);
    mWindow.getLayoutInflater().setPrivateFactory(this);
    if (info.softInputMode != WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED) {
        mWindow.setSoftInputMode(info.softInputMode);
    }
    if (info.uiOptions != 0) {
        mWindow.setUiOptions(info.uiOptions);
    }
    mUiThread = Thread.currentThread();

    ...
    //绑定window和windowManger
    mWindow.setWindowManager(
            (WindowManager)context.getSystemService(Context.WINDOW_SERVICE),
            mToken, mComponent.flattenToString(),
            (info.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0);
    if (mParent != null) {
        mWindow.setContainer(mParent.getWindow());
    }
    mWindowManager = mWindow.getWindowManager();
    ...
}

这个方法主要做的事情就是创建了应用的 window，是一个 PhoneWiondow，在 Activity 界面的创建和显示流程的时候还会看到这里。并且将当前线程设置成了主线程。我们在这个 fork 出来的新进程中还没有创建其他线程，这个 Activity 也是该 App 启动的第一个 Activity，所以这个 Activity 就是在主线程中运行的。

回到 performLaunchActivity 方法，调用了 Instrumentation 的 callActivityOnCreate() 方法，实现 Activity 的 onCreate 方法的调用

Instrumentation.java
public void callActivityOnCreate(Activity activity, Bundle icicle) {
    prePerformCreate(activity);
    activity.performCreate(icicle);
    postPerformCreate(activity);
}

Activity.java
final void performCreate(Bundle icicle) {
    performCreate(icicle, null);
}

final void performCreate(Bundle icicle, PersistableBundle persistentState) {
    dispatchActivityPreCreated(icicle);
    mCanEnterPictureInPicture = true;
    restoreHasCurrentPermissionRequest(icicle);
    if (persistentState != null) {diao
        onCreate(icicle, persistentState);
    } else {
        onCreate(icicle);
    }
    ......
}

以上是通过跟进 TransactionExecutor 的 executeCallbacks 方法，知道这里执行了 Activity 生命周期中的 onCreate 方法。我们接着看顺序执行的 TransactionExecutor 的 executeLifecycleState 方法的执行：

private void executeLifecycleState(ClientTransaction transaction) {
//获取ActivityLifecycleItem，我们知道这里获取的是我们之前添加的ResumeActivityItem
        final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
        if (lifecycleItem == null) {
            // No lifecycle request, return early.
            return;
        }

        final IBinder token = transaction.getActivityToken();
        final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
        if (DEBUG_RESOLVER) {
            Slog.d(TAG, tId(transaction) + "Resolving lifecycle state: "
                    + lifecycleItem + " for activity: "
                    + getShortActivityName(token, mTransactionHandler));
        }

        if (r == null) {
            // Ignore requests for non-existent client records for now.
            return;
        }

        // Cycle to the state right before the final requested state.
        //关键点,ResumeActivityItem的getTargetState　是　ON_RESUME
        cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */, transaction);

        // Execute the final transition with proper parameters.
        //执行 ResumeActivityItem 的 execute
        lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
        lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}

cycleToPath 函数非常重要，其中的 lifecycleItem.getTargetState() 返回值是 ON_RESUME。

private void cycleToPath(ActivityClientRecord r, int finish, boolean excludeLastState,
            ClientTransaction transaction) {
        final int start = r.getLifecycleState();//这里的start是ON_CREATE
        if (DEBUG_RESOLVER) {
            Slog.d(TAG, tId(transaction) + "Cycle activity: "
                    + getShortActivityName(r.token, mTransactionHandler)
                    + " from: " + getStateName(start) + " to: " + getStateName(finish)
                    + " excludeLastState: " + excludeLastState);
        }
        //这里的 start 是 ON_CREATE,finish 是 ON_RESUME
        //通过 mHelper 调用 getLifecyclePath 返回的 path 是 ON_START(以下有分析)
        //这里是 Activity 执行 onStart 函数的关键所在
        final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
        //执行path中的相关的生命周期函数
        performLifecycleSequence(r, path, transaction);
}

private void performLifecycleSequence(ActivityClientRecord r, IntArray path,
            ClientTransaction transaction) {
       //通过mHelper调用getLifecyclePath返回的path 是 ON_START
        final int size = path.size();
        for (int i = 0, state; i < size; i++) {
            state = path.get(i);
            if (DEBUG_RESOLVER) {
                Slog.d(TAG, tId(transaction) + "Transitioning activity: "
                        + getShortActivityName(r.token, mTransactionHandler)
                        + " to state: " + getStateName(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);
            }
        }
}

TransactionExecutorHelper.java

//excludeLastState 为 true, start 为 ON_CREATE,finish 为 ON_RESUME
public IntArray getLifecyclePath(int start, int finish, boolean excludeLastState) {
        if (start == UNDEFINED || finish == UNDEFINED) {
            throw new IllegalArgumentException("Can't resolve lifecycle path for undefined state");
        }
        if (start == ON_RESTART || finish == ON_RESTART) {
            throw new IllegalArgumentException(
                    "Can't start or finish in intermittent RESTART state");
        }
        if (finish == PRE_ON_CREATE && start != finish) {
            throw new IllegalArgumentException("Can only start in pre-onCreate state");
        }

        mLifecycleSequence.clear();
        if (finish >= start) {//走到此分支
            // just go there
            for (int i = start + 1; i <= finish; i++) {
            //把　ON_START　和 ON_RESUME 添加到 mLifecycleSequence 中
                mLifecycleSequence.add(i);
            }
        } else { // finish < start, can't just cycle down
            ......
        }

        // Remove last transition in case we want to perform it with some specific params.
        //　关键点:因为 excludeLastState 为 true,所以删除掉 ON_RESUME 状态
        if (excludeLastState && mLifecycleSequence.size() != 0) {
            mLifecycleSequence.remove(mLifecycleSequence.size() - 1);
        }

        return mLifecycleSequence;
    }

上面注释已经描述的很明确了，这里是顺序执行了 mTransactionHandler 的 handleStartActivity 和 handleResumeActivity 函数也就是 Activity 的 onStart 和 onResume 函数。

以上就是 ClientLifecycleManager 应用的整个流程。

参考：
https://www.jianshu.com/p/aa03c4458b9a
https://blog.csdn.net/weixin_42695485/article/details/108741913

Big Skipper

关注

4
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
深入理解 ClientLifecycleManager 机制

一　概述ClientLifecycleManager 是管理 Activity 生命周期的，在 ActivityTaskManagerService 里面提供 getLifecycleManager 来获取此对象，其中 mLifecycleManager 是在 ActivityTaskManagerService 的构造方法里面初始化的。ActivityTaskManagerService.javapublic class ActivityTaskManagerService extends IAct
复制链接

扫一扫