Activity启动流程全新版本(基于API 30)
Activity启动流程全新版本(基于API 30)
最新的AOSP源码对Activity的启动流程进行了非常大的改动，更好的支持Lifecycle。现在基于API 30源码熟悉一下全新的Activity启动流程。一年前阅读老版本AOSP写的博客仍然保留，传送门：Activity启动流程源码分析。
1、从startActivity开始
构造启动的Intent，一般通过Activity或者Context的startActivity(Intent intent)方法启动Activity。
1.1、通过Activity
从Activity类启动入口方法开始，经过多个调用链：
->startActivity(Intent intent)
->startActivity(Intent intent, @Nullable Bundle options)
->startActivityForResult(@RequiresPermission Intent intent, int requestCode)
->startActivityForResult(@RequiresPermission Intent intent, int requestCode,Bundle options)
最终在方法里通过Instrumentation开启启动Activity的漫长旅程（对于用户来说，只是点击一下，但是框架做了非常多的事情）
public void startActivityForResult(Intent intent, int requestCode,Bundle options) {
...
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode, options);
...
}1.2、通过Context
从Context类启动入口方法开始，经过两个调用链：
->startActivity(@RequiresPermission Intent intent)
->startActivity(Intent intent, Bundle options)
最终在ContextImpl类的实现方法中通过ActivityThread获取Instrumentation启动Activity
@Override
public void startActivity(Intent intent, Bundle options) {
...
mMainThread.getInstrumentation().execStartActivity(
getOuterContext(), mMainThread.getApplicationThread(), null,
(Activity) null, intent, -1, options);
}1.3、通过Instrumentation
前两小节分别从Activity和Context两个常用的Activity启动入口分析源码，最终都是通过APP的Instrumentation的execStartActivity(...)方法启动Activity。
public ActivityResult execStartActivity(Context who, IBinder contextThread, IBinder token,
Activity target,Intent intent, int requestCode, Bundle options) {
...
try {
intent.migrateExtraStreamToClipData(who);
intent.prepareToLeaveProcess(who);
int result = ActivityTaskManager.getService().startActivity(whoThread,
who.getBasePackageName(), who.getAttributionTag(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()), token,
target != null ? target.mEmbeddedID : null, requestCode, 0, null, options);
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}在上面的方法中通过ActivityTaskManager的getService()方法获取ActivityTaskManagerService(ATMS)系统服务。
public static IActivityTaskManager getService() {
return IActivityTaskManagerSingleton.get();
}这里的单例模板之前在单例的五种方式中提到过，用于获取ATMS AIDL服务接口。
private static final Singleton<IActivityTaskManager> IActivityTaskManagerSingleton =
new Singleton<IActivityTaskManager>() {
@Override
protected IActivityTaskManager create() {
final IBinder b = ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE);
return IActivityTaskManager.Stub.asInterface(b);
}
};2、进入系统服务
前面都在日常开发熟悉的android包下(frameworks/base/core/java/android)，通过获取系统服务进入到系统服务com.android.server包中(frameworks/base/services/core/java/com/android/server)。
2.1、ATMS
第1.3节中在应用层获取到系统服务接口IActivityTaskManager，调用startActivity(...)方法开始执行下面的调用链：
->startActivity(IApplicationThread caller, String callingPackage,String callingFeatureId, Intent intent, String resolvedType, IBinder resultTo,String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo,Bundle bOptions)
->startActivityAsUser(IApplicationThread caller, String callingPackage,String callingFeatureId, Intent intent, String resolvedType, IBinder resultTo,String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo,Bundle bOptions, int userId)
->startActivityAsUser(IApplicationThread caller, String callingPackage,@Nullable String callingFeatureId, Intent intent, String resolvedType,IBinder resultTo, String resultWho, int requestCode, int startFlags,ProfilerInfo profilerInfo, Bundle bOptions, int userId, boolean validateIncomingUser)
获取Activity启动控制器，从ActivityStartController中获取一个ActivityStarter启动器，一堆这是之后execute()启动。
private int startActivityAsUser(IApplicationThread caller, String callingPackage,
@Nullable String callingFeatureId, Intent intent, String resolvedType,
IBinder resultTo, String resultWho, int requestCode, int startFlags,
ProfilerInfo profilerInfo, Bundle bOptions, int userId, boolean validateIncomingUser) {
assertPackageMatchesCallingUid(callingPackage);
enforceNotIsolatedCaller("startActivityAsUser");
userId = getActivityStartController().checkTargetUser(userId, validateIncomingUser,
Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");
// TODO: Switch to user app stacks here.
return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
.setCaller(caller)
.setCallingPackage(callingPackage)
.setCallingFeatureId(callingFeatureId)
.setResolvedType(resolvedType)
.setResultTo(resultTo)
.setResultWho(resultWho)
.setRequestCode(requestCode)
.setStartFlags(startFlags)
.setProfilerInfo(profilerInfo)
.setActivityOptions(bOptions)
.setUserId(userId)
.execute();
}2.2、Activity启动控制器：ActivityStartController
ActivityStartController专门用来控制Activity的启动，通过obtainStarter(Intent intent, String reason)方法获取ActivityStarter。
/**
* @return A starter to configure and execute starting an activity. It is valid until after
* {@link ActivityStarter#execute} is invoked. At that point, the starter should be
* considered invalid and no longer modified or used.
*/
ActivityStarter obtainStarter(Intent intent, String reason) {
return mFactory.obtain().setIntent(intent).setReason(reason);
}mFactory是Factory工厂接口类型，该接口定义在ActivityStarter中。并且在ActivityStartController构造方法中初始化一个默认的实现ActivityStarter.DefaultFactory。
ActivityStartController(ActivityTaskManagerService service) {
this(service, service.mStackSupervisor,
new DefaultFactory(service, service.mStackSupervisor,
new ActivityStartInterceptor(service, service.mStackSupervisor)));
}
@VisibleForTesting
ActivityStartController(ActivityTaskManagerService service, ActivityStackSupervisor supervisor,
Factory factory) {
mService = service;
mSupervisor = supervisor;
mHandler = new StartHandler(mService.mH.getLooper());
mFactory = factory;
mFactory.setController(this);
mPendingRemoteAnimationRegistry = new PendingRemoteAnimationRegistry(service.mGlobalLock,
service.mH);
}2.3、Activity启动器：ActivityStarter
ActivityStartController中的ActivityStarter工厂默认实现类DefaultFactory就定义在这里：
static class DefaultFactory implements Factory {
/**
* The maximum count of starters that should be active at one time:
* 1. last ran starter (for logging and post activity processing)
* 2. current running starter
* 3. starter from re-entry in (2)
*/
private final int MAX_STARTER_COUNT = 3;
private ActivityStartController mController;
private ActivityTaskManagerService mService;
private ActivityStackSupervisor mSupervisor;
private ActivityStartInterceptor mInterceptor;
private SynchronizedPool<ActivityStarter> mStarterPool =
new SynchronizedPool<>(MAX_STARTER_COUNT);
DefaultFactory(ActivityTaskManagerService service,
ActivityStackSupervisor supervisor, ActivityStartInterceptor interceptor) {
mService = service;
mSupervisor = supervisor;
mInterceptor = interceptor;
}
@Override
public void setController(ActivityStartController controller) {
mController = controller;
}
@Override
public ActivityStarter obtain() {
ActivityStarter starter = mStarterPool.acquire();
if (starter == null) {
starter = new ActivityStarter(mController, mService, mSupervisor, mInterceptor);
}
return starter;
}
@Override
public void recycle(ActivityStarter starter) {
starter.reset(true /* clearRequest*/);
mStarterPool.release(starter);
}
}在获取到启动器之后经过一系列的setter方法设置各种属性，记得之前的源码倒数第二个调用是setMayWait(userId)，现在改成了setUserId(userId)。
return getActivityStartController().obtainStarter(intent, "startActivityAsUser") .setCaller(caller) .setCallingPackage(callingPackage) .setCallingFeatureId(callingFeatureId) .setResolvedType(resolvedType) .setResultTo(resultTo) .setResultWho(resultWho) .setRequestCode(requestCode) .setStartFlags(startFlags) .setProfilerInfo(profilerInfo) .setActivityOptions(bOptions) .setUserId(userId) .execute();
设置各种属性后，就开始执行execute()方法开启Activity的具体启动流程了。
int execute() {
try {
...
res = executeRequest(mRequest);
...
} finally {
onExecutionComplete();
}
}调用链：
->executeRequest(Request request)
->startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,int startFlags, boolean doResume, ActivityOptions options, Task inTask,boolean restrictedBgActivity, NeededUriGrants intentGrants)
->startActivityInner(final ActivityRecord r, ActivityRecord sourceRecord,IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,int startFlags, boolean doResume, ActivityOptions options, Task inTask,boolean restrictedBgActivity, NeededUriGrants intentGrants)
到这里代码有些跳动，稍有不慎都可能走错分支，我们只需关注重点逻辑。
int startActivityInner(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, Task inTask,
boolean restrictedBgActivity, NeededUriGrants intentGrants) {
setInitialState(r, options, inTask, doResume, startFlags, sourceRecord, voiceSession,
voiceInteractor, restrictedBgActivity);
//计算Activity启动Flag标志
computeLaunchingTaskFlags();
computeSourceStack();
//给启动Intent设置标志Flag
mIntent.setFlags(mLaunchFlags);
...
//处理Activity的入栈
mTargetStack.startActivityLocked(mStartActivity, topStack.getTopNonFinishingActivity(),
newTask, mKeepCurTransition, mOptions);
if (mDoResume) {
...
//这里真正启动放入栈顶的Activity
mRootWindowContainer.resumeFocusedStacksTopActivities(mTargetStack, mStartActivity, mOptions);
}
...
return START_SUCCESS;
}2.4、RootWindowContainer
RootWindowContainer继承自WindowContainer，是设备窗口的根容器。
boolean resumeFocusedStacksTopActivities(
ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
...
if (targetStack != null && (targetStack.isTopStackInDisplayArea()
|| getTopDisplayFocusedStack() == targetStack)) {
result = targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
}
for (int displayNdx = getChildCount() - 1; displayNdx >= 0; --displayNdx) {
...
if (focusedStack != null) {
result |= focusedStack.resumeTopActivityUncheckedLocked(target, targetOptions);
}
...
}
return result;
}
2.5、ActivityStack
进入管理Activity的栈中，方法调用链开始：
->resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options)
->resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options)
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
...
// Whoops, need to restart this activity!
...
mStackSupervisor.startSpecificActivity(next, true, false);
return true;
}
} else {
...
mStackSupervisor.startSpecificActivity(next, true, true);
}
return true;
}2.6、ActivityStackSupervisor
ActivityStackSupervisor类在API 30中改动非常大，和以往都不太一样。官方注释解释了：
//TODO：这个类成了垃圾场。 //-将与层次结构相关的内容移动到RootWindowContainer //-将与活动生命周期相关的东西移到一个名为ActivityLifeCycler的新类中 //-将接口内容移动到ActivityTaskManagerService。 //-所有其它的小东西移到其它文件。
ActivityStackSupervisor中的方法调用链如下：
->startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig)
->realStartActivityLocked(ActivityRecord r, WindowProcessController proc,boolean andResume, boolean checkConfig)
boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
boolean andResume, boolean checkConfig) throws RemoteException {
...
try {
...
// Create activity launch transaction.
final ClientTransaction clientTransaction = ClientTransaction.obtain(
proc.getThread(), r.appToken);
final DisplayContent dc = r.getDisplay().mDisplayContent;
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) {
lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward());
} else {
lifecycleItem = PauseActivityItem.obtain();
}
clientTransaction.setLifecycleStateRequest(lifecycleItem);
// Schedule transaction.
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
...
return true;
}3、Activity启动ClientTransaction
调用ActivityTaskManagerService的getLifecycleManager()方法获取ClientLifecycleManager生命周期管理实例
ClientLifecycleManager getLifecycleManager() {
return mLifecycleManager;
}调用ClientLifecycleManager的scheduleTransaction(ClientTransaction transaction)方法执行应用创建事务：
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();
}
}3.1、ClientTransaction
在框架的android.app.servertransaction包中，新增了很多和Activity生命周期事务相关的类。看来谷歌下功夫重构之前的屎山，重新用Lifecycle的方式管理生命周期。
接着Activity启动流程，执行ClientTransaction的schedule()方法。
public void schedule() throws RemoteException {
mClient.scheduleTransaction(this);
}mClient类型是IApplicationThread AIDL接口对象，实现是ActivityThread内部类ApplicationThread：
private class ApplicationThread extends IApplicationThread.Stub {
...
}从系统服务回到了客户端执行。
3.2、生命周期ClientTransactionItem
ClientTransactionItem是一个容器对象，保存一系列消息，这些消息可以发送给客户端。有很多派生类分别代表Activity不同的生命周期：LaunchActivityItem、NewIntentItem、StopActivityItem、PauseActivityItem、ResumeActivityItem、DestroyActivityItem。
其中启动Activity用到的是LaunchActivityItem。
/**
* Request to launch an activity.
* @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);
}
@Override
public void postExecute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
client.countLaunchingActivities(-1);
}
/** Obtain an instance initialized with provided params. */
public static LaunchActivityItem obtain(...);
if (instance == null) {
instance = new LaunchActivityItem();
}
...
return instance;
}4、ActivityThread
兜了一圈又从系统服务回到应用侧ActivityThread中，继续客户端侧的Activity启动流程。
4.1、ApplicationThread
ApplicationThread中scheduleTransaction(ClientTransaction transaction)方法实现如下
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
ActivityThread.this.scheduleTransaction(transaction);
}4.2、ClientTransactionHandler
调用ActivityThread中的实现，但是在ActivityThread类中并不能找到该方法。ActivityThread继承自ClientTransactionHandler抽象类，scheduleTransaction(ClientTransaction transaction)方法实现如下
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}sendMessage(int what, Object obj)方法在中是抽象方法，实现又回到了ActivityThread中：
void sendMessage(int what, Object obj) {
sendMessage(what, obj, 0, 0, false);
}进一步调用重载sendMessage(...)方法：
private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
if (DEBUG_MESSAGES) {
Slog.v(TAG,
"SCHEDULE " + what + " " + mH.codeToString(what) + ": " + arg1 + " / " + obj);
}
Message msg = Message.obtain();
msg.what = what;
msg.obj = obj;
msg.arg1 = arg1;
msg.arg2 = arg2;
if (async) {
msg.setAsynchronous(true);
}
mH.sendMessage(msg);
}mH是ActivityThread内部定义的H类，继承自Handler，关于Handler不用多说。
public void handleMessage(Message msg) {
if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
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;
...
}将和生命周期有关的事务抽取出来，放到父类ClientTransactionHandler中，比如启动应用的方法，它们的实现仍然放在ActivityThread中。
/** Perform activity launch. */ public abstract Activity handleLaunchActivity(ActivityThread.ActivityClientRecord r, PendingTransactionActions pendingActions, Intent customIntent); /** Perform activity start. */ public abstract void handleStartActivity(IBinder token, PendingTransactionActions pendingActions); ...
4.3、TransactionExecutor
通过TransactionExecutor的execute(ClientTransaction transaction)方法最终执行事务：
public void execute(ClientTransaction transaction) {
final IBinder token = transaction.getActivityToken();
...
executeCallbacks(transaction);
executeLifecycleState(transaction);
...
}executeCallbacks(ClientTransaction transaction)方法，执行具体ClientTransaction实例所对应的业务。
public void executeCallbacks(ClientTransaction transaction) {
final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
...
for (int i = 0; i < size; ++i) {
final ClientTransactionItem item = callbacks.get(i);
...
item.execute(mTransactionHandler, token, mPendingActions);
item.postExecute(mTransactionHandler, token, mPendingActions);
...
}
}executeLifecycleState(ClientTransaction transaction)方法，执行对应的生命周期事务。
/** Transition to the final state if requested by the transaction. */
private void executeLifecycleState(ClientTransaction transaction) {
final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
...
// Execute the final transition with proper parameters.
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}饶了一大圈，又回到ClientTransactionItem。在3.2节中提到启动Activity的事务LaunchActivityItem，其中execute()方法实现：
@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);
}4.4、回到ActivityThread执行handleLaunchActivity()真正创建Activity
执行client的handleLaunchActivity()方法，client是传入的mTransactionHandler，也就是ActivityThread
public Activity handleLaunchActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions, Intent customIntent) {
...
final Activity a = performLaunchActivity(r, customIntent);
...
return a;
}performLaunchActivity(ActivityClientRecord r, Intent customIntent)方法真正创建Activity：
/** Core implementation of activity launch. */
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
...
ContextImpl appContext = createBaseContextForActivity(r);
Activity activity = null;
//通过反射创建Activity实例
try {
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);
}
}
...
//调用activity的attach()方法建立Activity与Context之间的联系，
//创建PhoneWindow对象，并与Activity进行关联操作。
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);
...
//通过 Instrumentation执行Activity的onCreate()回调
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
...
return activity;
}attach(...)方法建立Activity与Context之间的联系，创建PhoneWindow对象，并与Activity进行关联操作
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*/);
mWindow = new PhoneWindow(this, window, activityConfigCallback);
...
mUiThread = Thread.currentThread();
mMainThread = aThread;
mInstrumentation = instr;
...
mWindowManager = mWindow.getWindowManager();
...
setAutofillOptions(application.getAutofillOptions());
}4.5、回调onCreate()
onCreate()回调流程执行callActivityOnCreate(Activity activity, Bundle icicle)：
public void callActivityOnCreate(Activity activity, Bundle icicle) {
prePerformCreate(activity);
activity.performCreate(icicle);
postPerformCreate(activity);
}调用Activity的performCreate(Bundle icicle)方法
final void performCreate(Bundle icicle) {
performCreate(icicle, null);
}在调用重载performCreate(Bundle icicle, PersistableBundle)方法，完成onCreate()回调，不仅有onCreate()，现在在onCreate()方法前后都插了回调方法，方便进行生命周期Lifecycle的监听，见ActivityLifecycleCallbacks的原理分析。
final void performCreate(Bundle icicle, PersistableBundle persistentState) {
dispatchActivityPreCreated(icicle);
...
if (persistentState != null) {
onCreate(icicle, persistentState);
} else {
onCreate(icicle);
}
...
dispatchActivityPostCreated(icicle);
}4.6、回调onResume()
既然都回调onCreate()方法了，那么Activity生命周期的onResume()、onPause()等生命周期回调在哪里呢？这些现在全部放在系统服务中处理，通过传递不同的ClientTransactionItem事务，通知客户端的Activity执行对应生命周期的回调方法。以onResume()为例，在2.5节Activity其中完毕之后的方法段里：
boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
boolean andResume, boolean checkConfig) throws RemoteException {
...
try {
...
// Create activity launch transaction.
...
final ActivityLifecycleItem lifecycleItem;
if (andResume) {
lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward());
} else {
lifecycleItem = PauseActivityItem.obtain();
}
clientTransaction.setLifecycleStateRequest(lifecycleItem);
// Schedule transaction.
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
...
return true;
}Activity启动事务添加了Lifecycle相关的生命周期回调对象ResumeActivityItem，在4.3节TransactionExecutor中通过executeLifecycleState(ClientTransaction transaction)方法执行生命周期回调：
/** Transition to the final state if requested by the transaction. */
private void executeLifecycleState(ClientTransaction transaction) {
final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
...
// Execute the final transition with proper parameters.
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}ResumeActivityItem的execute()方法定义如下，通过ActivityThread执行handleResumeActivity(...)方法回调onResume()生命周期。
@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);
}Activity其它生命周期回调也是如此，这样重构之后从框架层面支持Lifecycle生命周期管理。
推荐博客：
