本文基于Android 11.0源码分析
前言
继续上一篇分析Activity启动过程。
5.应用进程ActivityThread启动Activity的过程
ActivityThread类是应用初始化类，它的main()方法是应用的入口方法，它也是我们说的“主线程”，但是 ActivityThread本身不是一个线程，之所以称它为“主线程”，是因为它运行在主线程中。所以说ActivityThread是主线程的一部分，但不并能代表主线程。
-
ActivityThread负责创建Application对象以及管理其生命周期方法调用。
-
ActivityThread管理着四大组件的生命周期方法调用。
5.1 时序图
AMS15.png
5.2 ActivityThread#main()
// frameworks/base/core/java/android/app/ActivityThread.java
public final class ActivityThread extends ClientTransactionHandler {
// 初始化 ApplicationThread
final ApplicationThread mAppThread = new ApplicationThread();
// 初始化Handler，ApplicationThread和ActivityThread通信使用
final H mH = new H();
public static void main(String[] args) {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
......
// Call per-process mainline module initialization.
initializeMainlineModules();
Process.setArgV0("<pre-initialized>");
// 初始化主线程的Looper
Looper.prepareMainLooper();
...... // 获取 startSeq
// 实例化ActivityThread
ActivityThread thread = new ActivityThread();
// attach
thread.attach(false, startSeq);
if (sMainThreadHandler == null) {
// sMainThreadHandler = mH
sMainThreadHandler = thread.getHandler();
}
// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
// 开启Looper循环，等待接收消息
Looper.loop();
// 正常不会走到这里，除非是非正常退出了looper循环
throw new RuntimeException("Main thread loop unexpectedly exited");
}
----------------------------------------------------------
private void attach(boolean system, long startSeq) {
sCurrentActivityThread = this;
mSystemThread = system;
if (!system) {
android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",
UserHandle.myUserId());
RuntimeInit.setApplicationObject(mAppThread.asBinder());
final IActivityManager mgr = ActivityManager.getService();
try {
// 调用AMS的attachApplication()
mgr.attachApplication(mAppThread, startSeq);
}
......
} else {
android.ddm.DdmHandleAppName.setAppName("system_process",
UserHandle.myUserId());
try {
mInstrumentation = new Instrumentation();
mInstrumentation.basicInit(this);
ContextImpl context = ContextImpl.createAppContext(
this, getSystemContext().mPackageInfo);
mInitialApplication = context.mPackageInfo.makeApplication(true, null);
mInitialApplication.onCreate();
}
......
}
......
}
}
ActivityThread#attach()方法中，使用Binder通信跨进程调用到system_server进程中AMS的attachApplication()方法，并将ApplicationThread作为参数传递过去。
5.3 AMS绑定ApplicationThread
// frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
// ActivityTaskManagerInternal是一个抽象类，实现类是ATMS的内部类LocalService
// ATMS启动的时候，通过LocalServices#addService()注册到LocalServices
public ActivityTaskManagerInternal mAtmInternal;
public ActivityManagerService(Context systemContext, ActivityTaskManagerService atm) {
......
mAtmInternal = LocalServices.getService(ActivityTaskManagerInternal.class);
......
}
--------------------------------------------------------
public final void attachApplication(IApplicationThread thread, long startSeq) {
if (thread == null) {
throw new SecurityException("Invalid application interface");
}
synchronized (this) {
int callingPid = Binder.getCallingPid();
final int callingUid = Binder.getCallingUid();
final long origId = Binder.clearCallingIdentity();
attachApplicationLocked(thread, callingPid, callingUid, startSeq);
Binder.restoreCallingIdentity(origId);
}
}
--------------------------------------------------------
private boolean attachApplicationLocked(@NonNull IApplicationThread thread,
int pid, int callingUid, long startSeq) {
......
// 保存当前正在运行的进程的所有信息
ProcessRecord app;
......
try {
......
// 跨进程调用应用进程ApplicationThread#bindApplication()创建绑定Application
thread.bindApplication(processName, appInfo, providerList, null, profilerInfo,
null, null, null, testMode,
mBinderTransactionTrackingEnabled, enableTrackAllocation,
isRestrictedBackupMode || !normalMode, app.isPersistent(),
new Configuration(app.getWindowProcessController().getConfiguration()),
app.compat, getCommonServicesLocked(app.isolated),
mCoreSettingsObserver.getCoreSettingsLocked(),
buildSerial, autofillOptions, contentCaptureOptions,
app.mDisabledCompatChanges);
// Make app active after binding application or client may be running requests (e.g
// starting activities) before it is ready.
// 保存应用进程IApplicationThread
app.makeActive(thread, mProcessStats);
......
}
......
boolean didSomething = false;
// See if the top visible activity is waiting to run in this process...
if (normalMode) {
try {
// 通过ATMS启动根Activity
didSomething = mAtmInternal.attachApplication(app.getWindowProcessController());
}
......
}
return true;
}
AMS#attachApplication()方法，在获取到pid、uid后继续调用AMS#attachApplicationLocked()方法。
AMS#attachApplicationLocked()方法中关注以下流程：
-
通过跨进程通信调用应用进程中ApplicationThread#bindApplication()创建并绑定Application。
-
ProcessRecord调用makeActive()方法保存应用进程IApplicationThread。
-
通过ActivityTaskManagerInternal本地服务过渡到ATMS启动根Activity。
5.4 ActivityThread创建并绑定Application
IApplicationThread#bindApplication()方法调用的是应用进程中的实现类ApplicationThread#bindApplication()方法，方法中通过内部类H发送Handler消息(H.BIND_APPLICATION)，进而调用到ActivityThread#handleBindApplication()方法，代码如下：
// frameworks/base/core/java/android/app/ActivityThread.java
private void handleBindApplication(AppBindData data) {
......
final ContextImpl appContext = ContextImpl.createAppContext(this, data.info);
updateLocaleListFromAppContext(appContext,
mResourcesManager.getConfiguration().getLocales());
......
if (ii != null) {
......
final LoadedApk pi = getPackageInfo(instrApp, data.compatInfo,
appContext.getClassLoader(), false, true, false);
final ContextImpl instrContext = ContextImpl.createAppContext(this, pi,
appContext.getOpPackageName());
try {
// 获取ClassLoader加载类文件
final ClassLoader cl = instrContext.getClassLoader();
// 获取Instrumentation类并构建实例对象
mInstrumentation = (Instrumentation)
cl.loadClass(data.instrumentationName.getClassName()).newInstance();
}
......
final ComponentName component = new ComponentName(ii.packageName, ii.name);
mInstrumentation.init(this, instrContext, appContext, component,
data.instrumentationWatcher, data.instrumentationUiAutomationConnection);
......
}
......
Application app;
......
try {
// 创建Application
app = data.info.makeApplication(data.restrictedBackupMode, null);
......
mInitialApplication = app;
......
try {
mInstrumentation.onCreate(data.instrumentationArgs);
}
......
try {
// 内部调用Application#onCreate() 的方法
// 故Application#onCreate()比ActivityThread的main()方法慢执行
// 但是会比所有该应用Activity的生命周期先调用，因为此时的Activity还没启动
mInstrumentation.callApplicationOnCreate(app);
}
......
}
......
}
5.5 ProcessRecord保存ApplicationThread
// frameworks/base/services/core/java/com/android/server/am/ProcessRecord.java
public void makeActive(IApplicationThread _thread, ProcessStatsService tracker) {
......
thread = _thread;
mWindowProcessController.setThread(thread);
}
方法内将流程交给WindowProcessController并调用其setThread()方法存储IApplicationThread，代码如下：
// frameworks/base/services/core/java/com/android/server/wm/WindowProcessController.java
public class WindowProcessController extends ConfigurationContainer<ConfigurationContainer>
implements ConfigurationContainerListener {
private IApplicationThread mThread;
@HotPath(caller = HotPath.PROCESS_CHANGE)
public void setThread(IApplicationThread thread) {
synchronized (mAtm.mGlobalLockWithoutBoost) {
mThread = thread;
if (thread != null) {
setLastReportedConfiguration(getConfiguration());
}
}
}
IApplicationThread getThread() {
return mThread;
}
boolean hasThread() {
return mThread != null;
}
}
WindowProcessController#setThread()方法中将传入的IApplicationThread赋值给mThread中保存，此时 WindowProcessController中的IApplicationThread才有值，同时也解释了第二部分最后提出的问题。而我们在启动根Activity的时候，在《2.7 ActivityStackSupervisor》的startSpecificActivity()方法中通过wpc.hasThread()是获取不到IApplicationThread，是因为那时应用进程还没创建好，也就没有给WindowProcessController中的IApplicationThread赋值。
5.6 ATMS绑定WindowProcessController、启动根Activity
继续《5.3 AMS绑定ApplicationThread》代码逻辑：
if (normalMode) {
try {
// 通过ATMS启动根Activity
didSomething = mAtmInternal.attachApplication(app.getWindowProcessController());
}
......
}
// frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
// 启动的时候注册到 LocalServices 中
private void start() {
LocalServices.addService(ActivityTaskManagerInternal.class, mInternal);
}
final class LocalService extends ActivityTaskManagerInternal {
......
public boolean attachApplication(WindowProcessController wpc) throws RemoteException {
synchronized (mGlobalLockWithoutBoost) {
if (Trace.isTagEnabled(TRACE_TAG_WINDOW_MANAGER)) {
Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "attachApplication:" + wpc.mName);
}
try {
// 调用 RootWindowContainer#attachApplication()
return mRootWindowContainer.attachApplication(wpc);
} finally {
Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
}
}
}
......
}
}
ActivityTaskManagerInternal是一个抽象类，实现类是ATMS的内部类LocalService，这是一个本地服务，在ATMS启动的时候，通过LocalServices#addService()注册到LocalServices中。在AMS的构造方法中通过LocalServices#getService()方法获取到注册的本地服务。所以AMS中调用ActivityTaskManagerInternal的方法，实际上调用的是ATMS中的实现类LocalService的方法。该方法继续调用RootWindowContainer#attachApplication()方法，启动流程交给RootWindowContainer处理。
5.7 RootWindowContainer绑定WindowProcessController
// frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java
boolean attachApplication(WindowProcessController app) throws RemoteException {
final String processName = app.mName;
boolean didSomething = false;
for (int displayNdx = getChildCount() - 1; displayNdx >= 0; --displayNdx) {
final DisplayContent display = getChildAt(displayNdx);
final ActivityStack stack = display.getFocusedStack();
if (stack == null) {
continue;
}
mTmpRemoteException = null;
mTmpBoolean = false; // Set to true if an activity was started.
final PooledFunction c = PooledLambda.obtainFunction(
RootWindowContainer::startActivityForAttachedApplicationIfNeeded, this,
PooledLambda.__(ActivityRecord.class), app, stack.topRunningActivity());
stack.forAllActivities(c);
c.recycle();
if (mTmpRemoteException != null) {
throw mTmpRemoteException;
}
didSomething |= mTmpBoolean;
}
if (!didSomething) {
ensureActivitiesVisible(null, 0, false /* preserve_windows */);
}
return didSomething;
}
---------------------------------------------------------------
private boolean startActivityForAttachedApplicationIfNeeded(ActivityRecord r,
WindowProcessController app, ActivityRecord top) {
if (r.finishing || !r.okToShowLocked() || !r.visibleIgnoringKeyguard || r.app != null
|| app.mUid != r.info.applicationInfo.uid || !app.mName.equals(r.processName)) {
return false;
}
try {
// 调用ActivityStackSupervisor里面的方法
if (mStackSupervisor.realStartActivityLocked(r, app, top == r /*andResume*/,
true /*checkConfig*/)) {
mTmpBoolean = true;
}
} catch (RemoteException e) {
.....
return true;
}
return false;
}
RootWindowContainer#attachApplication()方法中，调用到RootWindowContainer的startActivityForAttachedApplicationIfNeeded()方法，如何调用到的该方法可以参考《3.2 ActivityTaskManagerService启动进程》。
RootWindowContainer#startActivityForAttachedApplicationIfNeeded() 方法中继续调用ActivityStackSupervisor#realStartActivityLocked()方法来真正的启动Activity。
5.8 获取ClientTransaction、添加Callback、设置LifecycleStateRequest
// frameworks/base/services/core/java/com/android/server/wm/ActivityStackSupervisor.java
boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
boolean andResume, boolean checkConfig) throws RemoteException {
final Task task = r.getTask();
final ActivityStack stack = task.getStack();
beginDeferResume();
try {
r.startFreezingScreenLocked(proc, 0);
......
try {
......
// Create activity launch transaction.
// 获取ClientTransaction实例
final ClientTransaction clientTransaction = ClientTransaction.obtain(
proc.getThread(), r.appToken);
final DisplayContent dc = r.getDisplay().mDisplayContent;
// ClientTransaction实例添加ClientTransactionItem类型的回调消息
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()));
// 所需的最终生命周期状态请求
final ActivityLifecycleItem lifecycleItem;
// 判断此时的生命周期状态是走onResume还是onPause
if (andResume) {
// 由于此时ActivityStack栈中只有一个Activity
// 所以top==r为true，因此应赋值为ResumeActivityItem
lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward());
} else {
lifecycleItem = PauseActivityItem.obtain();
}
// 设置执行transaction后的最终的生命周期状态请求
clientTransaction.setLifecycleStateRequest(lifecycleItem);
// ClientLifecycleManager调度ClientTransaction
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
......
} catch (RemoteException e) {
// 启动失败，移除 ActivityRecord
r.launchFailed = true;
proc.removeActivity(r);
throw e;
}
} finally {
endDeferResume();
}
return true;
}
该方法执行流程如下：
-
创建ClientTransaction实例，其中参数proc.getThread()是IApplicationThread类型，mActivityToken为IBinder类型。
-
ClientTransaction实例添加ClientTransactionItem类型的回调消息，注意：这里添加的是LaunchActivityItem实例，LaunchActivityItem继承自ClientTransactionItem抽象类并实现其中的方法。
-
获取ClientLifecycleManager实例，调用其scheduleTransaction()方法去调度转换事务Transaction的执行。
5.9 ClientTransaction获取、添加事务回调
// frameworks/base/core/java/android/app/servertransaction/ClientTransaction.java
// 客户端的单个回调列表
@UnsupportedAppUsage
private List<ClientTransactionItem> mActivityCallbacks;
// 执行事务后客户端活动应处于的最终生命周期状态
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;
/** Obtain an instance initialized with provided params. */
// 获取ClientTransaction实例
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 的 callbacks 列表尾部添加 ClientTransactionItem 类型的消息
* 参数：包含生命周期请求或回调的单个消息
* @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);
}
/**
* 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;
}
ClientTransaction是保存一系列待发送给客户端处理的事务消息的容器，包括一个Callback列表和一个最终生命周期状态。
5.10 ClientLifecycleManager客户端生命周期事务转换管理器
回到《5.8小结》中，继续scheduleTransaction()的流程：
// frameworks/base/services/core/java/com/android/server/wm/ClientLifecycleManager.java
/**
* Schedule a transaction, which may consist of multiple callbacks and a lifecycle request.
* 安排调度一个事务（启动、暂停等 Activity 事务），可能包含多个回调和一个生命周期请求
* @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();
}
}
ClientLifecycleManager能够组合多个客户端生命周期转换请求与回调，并将其作为单个事务调度执行。
5.11 ClientTransaction#schedule()调度事务
// frameworks/base/core/java/android/app/servertransaction/ClientTransaction.java
/**
* Schedule the transaction after it was initialized. It will be send to client and all its
* individual parts will be applied in the following sequence:
* 1\. The client calls {@link #preExecute(ClientTransactionHandler)}, which triggers all work
* that needs to be done before actually scheduling the transaction for callbacks and
* lifecycle state request.
* 2\. The transaction message is scheduled.
* 3\. The client calls {@link TransactionExecutor#execute(ClientTransaction)}, which executes
* all callbacks and necessary lifecycle transitions.
*/
public void schedule() throws RemoteException {
mClient.scheduleTransaction(this);
}
看一下方法的注释，大概意思是事务初始化之后调度事务，其所有单独部分将按以下顺序发送到客户端：
-
客户端调用preExecute()方法，在实际调度事务的回调和生命周期状态请求之前，触发所有需要完成的任务。
-
事务消息已被调度。
-
客户端调用TransactionExecutor#execute() 方法，执行所有回调和必要的生命周期转换。
通过上面第8、9小节的源码解析可以看出，这里mClient是IApplicationThread 类型，它是极其重要的一个Binder接口，维护了应用进程和system_server进程中AMS之间的IPC通讯，mClient就是应用进程在系统进程中的代理对象，AMS通过mClient与此时作为服务端的应用进程进行通信。而应用进程中的实现类ApplicationThread是ActivityThread的内部类，继承自IApplicationThread.Stub，实现了Binder接口，此时作为服务端接受 system_server进程中AMS发出的请求并执行，也就是流程切到应用进程继续执行。
5.12 ActivityThread调度事务
// frameworks/base/core/java/android/app/ClientTransactionHandler.java
public abstract class ClientTransactionHandler {
/** Prepare and schedule transaction for execution. */
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
// 发送 Handler 消息到 ActivityThread.H 中
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
/**
* Get the {@link TransactionExecutor} that will be performing lifecycle transitions and
* callbacks for activities.
*/
abstract TransactionExecutor getTransactionExecutor();
// ActivityThread 实现该抽象方法，然后调用其内部的 mH 发送消息并处理
abstract void sendMessage(int what, Object obj);
}
------------------------------------------------------------
// frameworks/base/core/java/android/app/ActivityThread.java
public final class ActivityThread extends ClientTransactionHandler {
final H mH = new H();
// An executor that performs multi-step transactions.
private final TransactionExecutor mTransactionExecutor = new TransactionExecutor(this);
// 应用进程中IApplicationThread的实现类，继续调用 ActivityThread 的方法
private class ApplicationThread extends IApplicationThread.Stub {
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
// 执行父类 ClientTransactionHandler # scheduleTransaction()
ActivityThread.this.scheduleTransaction(transaction);
}
}
class H extends Handler {
......
public static final int EXECUTE_TRANSACTION = 159; // 执行事务
public void handleMessage(Message msg) {
......
switch (msg.what) {
......
case EXECUTE_TRANSACTION:
// 获取传递过来的 ClientTransaction
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();
}
// TODO(lifecycler): Recycle locally scheduled transactions.
break;
......
}
......
}
}
void sendMessage(int what, Object obj) {
sendMessage(what, obj, 0, 0, false);
}
private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
......
Message msg = Message.obtain();
msg.what = what;
msg.obj = obj;
msg.arg1 = arg1;
msg.arg2 = arg2;
if (async) {
msg.setAsynchronous(true);
}
mH.sendMessage(msg);
}
}
执行流程如下：
-
ApplicationThread#scheduleTransaction()方法中又继续调用ActivityThread#scheduleTransaction()方法，而ActivityThread自身没有这个方法，因此执行父类ClientTransactionHandler#scheduleTransaction() 方法。
-
ClientTransactionHandler#scheduleTransaction()方法中通过继承自Handler的实现类H发送消息到ActivityThread 中，并重写了其 handleMessage()方法。
-
H#handleMessage()方法中获取传递过来的ClientTransaction，并由TransactionExecutor#execute()执行该 ClientTransaction的转换。
5.13 TransactionExecutor事务转换执行器
// frameworks/base/core/java/android/app/servertransaction/ClientTransaction.java
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) {
// 执行销毁与该token有关的Activity的事务，然后与此有关的记录将被移除
activitiesToBeDestroyed.remove(token);
}
if (mTransactionHandler.getActivityClient(token) == null) {
// Activity还未完成创建就请求销毁，所以与这个token有关的事务都要取消
Slog.w(TAG, tId(transaction) + "Skip pre-destroyed transaction:\n"
+ transactionToString(transaction, mTransactionHandler));
return;
}
}
}
// 执行事务的回调 -- 第 8 小节中添加到 ClientTransaction 中的回调 -- LaunchActivityItem
executeCallbacks(transaction);
// 执行生命周期状态
executeLifecycleState(transaction);
mPendingActions.clear();
}
-----------------------------------------------------------------
/**
* Cycle through all states requested by callbacks and execute them at proper times.
* 循环遍历回调列表中的所有状态请求，在适当的时间执行它们
*/
public void executeCallbacks(ClientTransaction transaction) {
final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
if (callbacks == null || callbacks.isEmpty()) {
return;
}
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) {
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);
}
// 获取到LaunchActivityItem并调用其execute()方法
item.execute(mTransactionHandler, token, mPendingActions);
item.postExecute(mTransactionHandler, token, mPendingActions);
if (r == null) {
// 启动活动请求将创建一个活动记录
r = mTransactionHandler.getActivityClient(token);
}
if (postExecutionState != UNDEFINED && r != null) {
final boolean shouldExcludeLastTransition =
i == lastCallbackRequestingState && finalState == postExecutionState;
cycleToPath(r, postExecutionState, shouldExcludeLastTransition, transaction);
}
}
}
TransactionExecutor#executeCallbacks() 方法中，循环遍历回调列表中的所有状态请求，并在适当的时间执行添加的状态请求，这里即《5.8 获取ClientTransaction、添加Callback、设置LifecycleStateRequest》中添加到 ClientTransaction中的LaunchActivityItem。
5.14 LaunchActivityItem请求启动Activity
// frameworks/base/core/java/android/app/servertransaction/LaunchActivityItem.java
/**
1\. Request to launch an activity.
2\. 请求启动 Activity
3\. @hide
*/
public class LaunchActivityItem extends ClientTransactionItem {
@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, mFixedRotationAdjustments);
client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}
}
ClientTransactionHandler是一个抽象类，ActivityThread继承自ClientTransactionHandler并实现了其抽象方法，所以这里又回到了ActivityThread 类，调用其handleLaunchActivity()方法来启动Activity。
5.15 ActivityThread执行启动Activity事务
// frameworks/base/core/java/android/app/ActivityThread.java
@Override
public Activity handleLaunchActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions, Intent customIntent) {
......
WindowManagerGlobal.initialize();
// Hint the GraphicsEnvironment that an activity is launching on the process.
GraphicsEnvironment.hintActivityLaunch();
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 {
// 启动Activity发生异常，不论是什么原因，通知ATMS终止此 Activity
try {
ActivityTaskManager.getService()
.finishActivity(r.token, Activity.RESULT_CANCELED, null,
Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
return a;
}
-----------------------------------------------------------------
/** Core implementation of activity launch. */
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
ActivityInfo aInfo = r.activityInfo;
if (r.packageInfo == null) {
r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
Context.CONTEXT_INCLUDE_CODE);
}
......
// 创建Activity的Context
ContextImpl appContext = createBaseContextForActivity(r);
Activity activity = null;
try {
// 通过ClassLoader反射获取Activity的实例
java.lang.ClassLoader cl = appContext.getClassLoader();
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) {
......
appContext.getResources().addLoaders(
app.getResources().getLoaders().toArray(new ResourcesLoader[0]));
appContext.setOuterContext(activity);
// 执行Activity的attach、初始化Window等
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);
......
activity.mCalled = false;
// 执行Activity的onCreate
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
......
r.activity = activity;
mLastReportedWindowingMode.put(activity.getActivityToken(),
config.windowConfiguration.getWindowingMode());
}
// 设置生命周期的状态为ON_CREATE
r.setState(ON_CREATE);
synchronized (mResourcesManager) {
mActivities.put(r.token, r);
}
}
......
return activity;
}
performLaunchActivity()方法执行流程：
-
调用createBaseContextForActivity()方法创建ContextImpl对象，该方法中调用ContextImpl#createActivityContext()方法创建ContextImpl 对象。
-
调用Instrumentation#newActivity()方法加载并新建Activity，该方法中调用AppComponentFactory#instantiateActivity() 方法，后通过在performLaunchActivity()方法中新建的 ClassLoader加载新建Activity类。
-
通过LoadApk#makeApplication()方法创建一个Application对象，过程跟加载新建Activity类似，用到ClassLoader。
-
执行Activity#attach()方法，ContextImpl通过该方法来和Activity建立关联，除此之外，方法中还完成了 Window实例的创建并建立自己和Window的关联，这样当Window接收到外部输入事件后就可以将事件传递给 Activity。
-
执行Instrumentation#callActivityOnCreate()方法，该方法中调用Activity#performCreate()方法，Activity#performCreate()方法中调用Activity#onCreate() 方法。
流程走到这里Activity#onCreate()方法执行完，并设置生命周期的状态为ON_CREATE，还有onStart、onResume等生命周期方法呢？
5.16 ActivityThread执行生命周期事务
回看《5.13 TransactionExecutor事务转换执行器》，之前我们只分析了TransactionExecutor#executeCallbacks(transaction)执行回调有关的流程，现在我们来看一下 TransactionExecutor#executeLifecycleState(transaction)方法。
// frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java
/** 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();
// 获取ActivityClientRecord，该对象保存Activity的启动信息
final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
......
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);
}
TransactionExecutor#executeLifecycleState(transaction)方法主要是用来转换Activity的生命周期状态至设置的最终状态并执行，流程如下：
-
获取《5.8 获取ClientTransaction、添加Callback、设置LifecycleStateRequest》中设置的执行transaction后的最终的生命周期状态请求，也就是设置的ResumeActivityItem。
-
获取保存Activity启动信息的ActivityRecord对象，调用cycleToPath()方法获取并执行设置的生命周期请求最终状态之前的状态。
-
调用ActivityLifecycleItem#execute()方法执行设置的生命周期事务的最终转换，这里实际调用的是 ResumeActivityItem#execute() 方法。
5.17 TransactionExecutor执行中间态生命周期请求事务
何为中间态生命周期请求事务？ Android系统针对Activity的生命周期，定义了与之相对应的XXXActivityItem 类，如StartActivityItem、PauseActivityItem等，即为处于中间态的生命周期请求事务。
那这些中间态的生命周期请求事务什么时候会被执行呢？如StartActivityItem对应的Activity的生命周期请求 onStart是在何时触发的呢？
// frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java
private void cycleToPath(ActivityClientRecord r, int finish, boolean excludeLastState,
ClientTransaction transaction) {
final int start = r.getLifecycleState();
......
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);
.......
switch (state) {
case ON_CREATE:
mTransactionHandler.handleLaunchActivity(r, mPendingActions,
null /* customIntent */);
break;
case ON_START:
mTransactionHandler.handleStartActivity(r.token, mPendingActions);
break;
......
}
}
}
方法的执行流程如下：
-
获取待启动Activity当前的生命周期状态，由于Activity#onCreate()方法执行完，并设置生命周期的状态为 ON_CREATE，所以start为ON_CREATE。在上一节中我们知道设置的最终的生命周期状态请求是 ResumeActivityItem，其getTargetState()方法返回的是ON_RESUME。
-
通过TransactionExecutorHelper对象调用其getLifecyclePath()方法，获取此次要执行生命周期的路径，方法中根据start和finish状态来构造一个IntArray 类型的状态数组。
-
调用TransactionExecutor#performLifecycleSequence()方法中，遍历构建的状态序列执行应用进程中对应的 ActivityThread handleXXXActivity()方法完成生命周期状态的转换。
看到这里，还是未明确找到Activity生命周期的onStart在何时、何地执行的？但是TransactionExecutorHelper 这个辅助类值得关注，通过TransactionExecutorHelper#getLifecyclePath()方法来获取此次要执行生命周期的路径，看看这个方法怎么做的？
5.18 TransactionExecutorHelper获取待执行生命周期的状态序列
先看一下ON_START、ON_RESUME等这些生命周期状态的定义，方便我们理解后续流程。
// frameworks/base/core/java/android/app/servertransaction/ActivityLifecycleItem.java
/**
* 请求 Activity 应该达到的生命周期状态
*/
public abstract class ActivityLifecycleItem extends ClientTransactionItem {
......
@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();
}
与Activity生命周期有关的StartActivityItem、ResumeActivityItem等继承自该抽象类并实现其抽象方法getTargetState()，方法中返回对应的生命周期，注意：LaunchActivityItem直接继承自ClientTransactionItem。
结合上面这个抽象类来分析TransactionExecutorHelper#getLifecyclePath() 方法，代码如下：
// frameworks/base/core/java/android/app/servertransaction/TransactionExecutorHelper.java
@VisibleForTesting
public IntArray getLifecyclePath(int start, int finish, boolean excludeLastState) {
......
// 清空生命周期状态序列
mLifecycleSequence.clear();
if (finish >= start) {
if (start == ON_START && finish == ON_STOP) {
// 如果很快从ON_START转换到ON_STOP状态，此时不需要经历恢复、暂停状态
mLifecycleSequence.add(ON_STOP);
} else {
// 添加start到finish之间的生命周期状态
for (int i = start + 1; i <= finish; i++) {
mLifecycleSequence.add(i);
}
}
}
......
// 根据条件判断移除最后的生命周期状态
if (excludeLastState && mLifecycleSequence.size() != 0) {
mLifecycleSequence.remove(mLifecycleSequence.size() - 1);
}
return mLifecycleSequence;
}
经过之前的分析，可知TransactionExecutorHelper#getLifecyclePath()方法中传入的start为ON_CREATE，finish为 ON_RESUME，excludeLastState为true。由ActivityLifecycleItem抽象类定义可知finish >= start，因此方法中可以只关注这部分的逻辑处理，通过比较可以发现ON_CREATE和ON_RESUME中间还有ON_START这个中间状态，所以在mLifecycleSequence状态序列中将添加ON_START和ON_RESUME状态，此时因为excludeLastState为true，所以最后会移除掉ON_RESUME状态，故返回的状态序列中只包含ON_START状态，即cycleToPath()方法中获得的path 中只包含ON_START状态。
所以此时，回到《5.17 TransactionExecutor执行中间态生命周期请求事务》分析performLifecycleSequence()方法，此时遍历构建的状态序列中只有ON_START状态值，因此执行应用进程中对应的ActivityThread#handleStartActivity()方法完成生命周期状态的转换，方法调用流程如下：
-
ActivityThread # handleStartActivity() 方法中调用 activity # performStart() 方法，设置生命周期的状态为 ON_START。
-
Activity # performStart() 方法中调用 Instrumentation # callActivityOnStart() 方法，Instrumentation # callActivityOnStart() 方法中调用 Activity # onStart() 方法。
流程走到这里Activity#onStart()方法执行完，并设置生命周期的状态为ON_START，继续分析onResume生命周期方法的调用过程？
5.19 TransactionExecutor执行生命周期事务的最终转换
回看《5.16 ActivityThread执行生命周期事务》中，最后会执行已设置的生命周期事务的最终转换，通过前面的分析，这里执行的是ResumeActivityItem#execute() 方法，代码如下：
// frameworks/base/core/java/android/app/servertransaction/ResumeActivityItem.java
@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);
}
上面分析过ClientTransactionHandler是一个抽象类，ActivityThread继承自ClientTransactionHandler并实现了其抽象方法，所以这里调用的是ActivityThread#handleResumeActivity()方法，不在贴源码，方法调用流程如下：
-
ActivityThread#handleResumeActivity()方法调用ActivityThread#performResumeActivity() 方法，设置生命周期的状态为ON_RESUME。
-
ActivityThread#performResumeActivity()方法调用Activity#performResume()方法。Activity#performResume()方法中调用Instrumentation#callActivityOnResume()方法，Instrumentation#callActivityOnResume()方法中调用Activity#onResume()方法。
6.总结
至此，基于Android R（11.0）我们终于解析完Activity的启动过程，本篇主要是分析根Activity的启动流程，根 Activity也是Activity，因此去掉本篇中关于启动进程Launcher、孵化进程Zygote等有关的篇幅，也即普通Activity 的启动过程，这里不再单独分析。
此外，有关 ClientTransaction 部分值得深入学习，这是 Android P（9.0）加入的，其作用如下：
-
减少通信次数：系统进程中AMS到应用进程，一次通信，包含各种通信事件和内容。
-
统筹消息域：将生命周期变化与事件更新分类统筹，分别处理。
-
减少两端耦合：系统进程中AMS对于生命周期的发送要求，与应用进程对生命周期的处理需求并不对等，所以应用进程会自己组装完整的生命周期回调，处理逻辑更内聚。
网友评论