onStart()调用时机
ON_START生命周期
我们知道正常Activity生命周期由onCreate() -> onStart() -> onResume()，但是我们在Activity启动的时候并没有向ApplicationThread请求处理StartActivityItem，而是创建了一个LaunchActivityItem(启动事务item，对应ClientTransaction.addCallback())和ResumeActivityItem(属于生命周期事务item,对应ClientTransaction.setLifecycleStateRequest())：（具体启动流程文章请看
①浅析ActivityThread#main()方法和生命周期事务处理（代码基于Android-12）
，
②当我点击桌面App的图标时发生了什么-浅析Activity启动流程（代码基于Android-12
）
ActivityTaskSupervisor#realStartActivityLocked()
boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
boolean andResume, boolean checkConfig) throws RemoteException {
// ....
// 创建事务
final ClientTransaction clientTransaction = ClientTransaction.obtain(
proc.getThread(), r.token);
final boolean isTransitionForward = r.isTransitionForward();
final IBinder fragmentToken = r.getTaskFragment().getFragmentToken();
// 1.创建启动activity事务到待处理列表中[LaunchActivityItem]
clientTransaction.addCallback(LaunchActivityItem.obtain(超长参数);
// 2。创建ActivityLifecycleItem对象
final ActivityLifecycleItem lifecycleItem;
// andResume为true，onPause在onResume后面
if (andResume) {
// 设置resume-item
lifecycleItem = ResumeActivityItem.obtain(isTransitionForward);
} else {
// 设置pause-item
lifecycleItem = PauseActivityItem.obtain();
}
// 设置lifecycle请求,也就是onCreate之后是onResume
clientTransaction.setLifecycleStateRequest(lifecycleItem);
// Schedule transaction.
// 开始处理事务!~!!!!!!
// mService是ActivityTaskManagerService，获取到的lm是ClientLifecycleManager对象
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
// ....
}
然后会由ActivityThread.H来处理消息H.EXECUTE_TRANSACTION,此时obj为上面创建的ClientTransaction对象
，内部的mActivityCallbacks(集合)中有LaunchActivityItem, mLifecycleStateRequest对象为ReusmeActivityItem。[源码请看：
] 在handleMessage()中间接调用TransactionExecutor.execute()处理事务：
public void execute(ClientTransaction transaction) {
// 与 onDestory有关
...
// 分2步处理callback和lifecycleRequest
// 处理 LaunchActivityItem
executeCallbacks(transaction);
// 处理 ResumeActivityItem
executeLifecycleState(transaction);
}
-
到这需要看一下
LaunchActivityItem和ResumeActivityItem的类结构和重要常量public abstract class ClientTransactionItem implements BaseClientRequest, Parcelable { @ActivityLifecycleItem.LifecycleState public int getPostExecutionState() { return UNDEFINED; } @Override public int describeContents() { return 0; } } public class LaunchActivityItem extends ClientTransactionItem { // 没有重写 父类 ClientTransactionItem.getPostExecutionState() // 所以 LaunchActivityItem.getPostExecutionState() == UNDEFINED } public abstract class ActivityLifecycleItem extends ActivityTransactionItem[继承了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() { } } public class ResumeActivityItem extends ActivityLifecycleItem { // 没有重写 父类 ClientTransactionItem.getPostExecutionState() // 所以 ResumeActivityItem.getPostExecutionState() == UNDEFINED @Override public int getTargetState() { return ON_RESUME; } }
处理LaunchActivityItem -----> TransactionExecutor#executeCallbacks()
生命周期状态获取辅助类对象
mHelper是TransactionExecutorHelper.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);
// 得到的是ResumeActivityItem
final ActivityLifecycleItem finalStateRequest = transaction.getLifecycleStateRequest();
// 获取生命周期状态，ResumeActivityItem.getTargetState()==ON_RESUME
// 所以这里 finalState为ON_RESUME
final int finalState = finalStateRequest != null ? finalStateRequest.getTargetState()
: UNDEFINED;
// Index of the last callback that requests some post-execution state.
// 通过TransactionExecutorHelper获取上一个状态，这里返回的是-1(UNDEFINED)
final int lastCallbackRequestingState = lastCallbackRequestingState(transaction);
final int size = callbacks.size();
for (int i = 0; i < size; ++i) {
final ClientTransactionItem item = callbacks.get(i);
// LaunchActivityItem的这个方法返回的是 UNDEFINED
final int postExecutionState = item.getPostExecutionState();
// 获取最接近的什么周期状态，这里获取到的是 UNDEFINED
final int closestPreExecutionState = mHelper.getClosestPreExecutionState(r,
item.getPostExecutionState());
// 不满足条件
if (closestPreExecutionState != UNDEFINED) {
cycleToPath(r, closestPreExecutionState, transaction);
}
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);
}
}
}
处理ResumeActivityItem -----> TransactionExecutor#executeLifecycleState()：修正生命周期
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 (r == null) {
// Ignore requests for non-existent client records for now.
return;
}
// Cycle to the state right before the final requested state.
// 修正生命周期请求链！！！！！！
// 注意传进来的参数 exclueLastState表示已经包括本次生命周期ON_RESUME
cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */, transaction);
// Execute the final transition with proper parameters.
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}
在executeLifecycleState()中需要修正生命周期请求以确保正确的生命周期循环！通过调用cycleToPath()方法（抽象的命名=_=）
private void cycleToPath(ActivityClientRecord r, int finish, boolean excludeLastState,
ClientTransaction transaction) {
// 获取到的start为 ON_CREATE,因为是启动
final int start = r.getLifecycleState();
// 修正生命周期请求链, start==ON_CREATE, finish==ON_RESUME
final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
performLifecycleSequence(r, path, transaction);
}
TransactionExecutorHelper#getLifecyclePath():
// start==ON_CREATE, finish==ON_RESUME
public IntArray getLifecyclePath(int start, int finish, boolean excludeLastState) {
// start==ON_CREATE, finish==ON_RESUME不满足
if (start == UNDEFINED || finish == UNDEFINED) {
throw new IllegalArgumentException("Can't resolve lifecycle path for undefined state");
}
// start==ON_CREATE, finish==ON_RESUME不满足
if (start == ON_RESTART || finish == ON_RESTART) {
throw new IllegalArgumentException(
"Can't start or finish in intermittent RESTART state");
}
// start==ON_CREATE, finish==ON_RESUME 不满足
if (finish == PRE_ON_CREATE && start != finish) {
throw new IllegalArgumentException("Can only start in pre-onCreate state");
}
// 清空请求链，这是个大小为 6 的int数组
mLifecycleSequence.clear();
// start==ON_CREATE, finish==ON_RESUME满足
if (finish >= start) {
// start==ON_CREATE, finish==ON_RESUME不满足
if (start == ON_START && finish == ON_STOP) {
// A case when we from start to stop state soon, we don't need to go
// through the resumed, paused state.
mLifecycleSequence.add(ON_STOP);
} else {
// just go there
// start==ON_CREATE, finish==ON_RESUME满足！重新填充生命周期
// 从2 -> 3, 循环俩次，添加了2和3, 分别对应的常量为 ON_START, ON_RESUME
for (int i = start + 1; i <= finish; i++) {
mLifecycleSequence.add(i);
}
}
} else { // finish < start, can't just cycle down
if (start == ON_PAUSE && finish == ON_RESUME) {
// Special case when we can just directly go to resumed state.
mLifecycleSequence.add(ON_RESUME);
} else if (start <= ON_STOP && finish >= ON_START) {
// Restart and go to required state.
// Go to stopped state first.
for (int i = start + 1; i <= ON_STOP; i++) {
mLifecycleSequence.add(i);
}
// Restart
mLifecycleSequence.add(ON_RESTART);
// Go to required state
for (int i = ON_START; i <= finish; i++) {
mLifecycleSequence.add(i);
}
} else {
// Relaunch and go to required state
// Go to destroyed state first.
for (int i = start + 1; i <= ON_DESTROY; i++) {
mLifecycleSequence.add(i);
}
// Go to required state
for (int i = ON_CREATE; i <= finish; i++) {
mLifecycleSequence.add(i);
}
}
}
// 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);
}
// 此时mLifecycleSequence请求链还剩 ON_START
return mLifecycleSequence;
}
经过上面的重新链接，返回的生命周期链为[ON_START]，接下来继续执行performLifecycleSequence(r, path, transaction);
private void performLifecycleSequence(ActivityClientRecord r, IntArray path,
ClientTransaction transaction) {
// size大小为 1， 只有一个ON_START
final int size = path.size();
for (int i = 0, state; i < size; i++) {
// state == ON_START
state = path.get(i);
switch (state) {
case ON_CREATE:
mTransactionHandler.handleLaunchActivity(r, mPendingActions,
null /* customIntent */);
break;
// 走这里！
case ON_START:
// mTransactionHandler为ActivityThread对象，继而执行其handleStartActivity()
mTransactionHandler.handleStartActivity(r, mPendingActions,
null /* activityOptions */);
break;
case ON_RESUME:
mTransactionHandler.handleResumeActivity(r, false /* finalStateRequest */,
r.isForward, "LIFECYCLER_RESUME_ACTIVITY");
break;
case ON_PAUSE:
mTransactionHandler.handlePauseActivity(r, false /* finished */,
false /* userLeaving */, 0 /* configChanges */, mPendingActions,
"LIFECYCLER_PAUSE_ACTIVITY");
break;
case ON_STOP:
mTransactionHandler.handleStopActivity(r, 0 /* configChanges */,
mPendingActions, false /* finalStateRequest */,
"LIFECYCLER_STOP_ACTIVITY");
break;
case ON_DESTROY:
mTransactionHandler.handleDestroyActivity(r, false /* finishing */,
0 /* configChanges */, false /* getNonConfigInstance */,
"performLifecycleSequence. cycling to:" + path.get(size - 1));
break;
case ON_RESTART:
mTransactionHandler.performRestartActivity(r, false /* start */);
break;
default:
throw new IllegalArgumentException("Unexpected lifecycle state: " + state);
}
}
}
修正之后执行了
ActivityThread.handleStartActivity(),和之前分析onCreate()、onResume()逻辑是差不多的，最后都是调用Instrumentation.callXXX()方法！
ActivityThread#handleStartActivity()
@Override
public void handleStartActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions, ActivityOptions activityOptions) {
final Activity activity = r.activity;
if (!r.stopped) {
throw new IllegalStateException("Can't start activity that is not stopped.");
}
if (r.activity.mFinished) {
// TODO(lifecycler): How can this happen?
return;
}
unscheduleGcIdler();
if (activityOptions != null) {
activity.mPendingOptions = activityOptions;
}
// Start
// 调用Activity.performStart()
activity.performStart("handleStartActivity");
r.setState(ON_START);
if (pendingActions == null) {
// No more work to do.
return;
}
// Restore instance state
// restore相关
if (pendingActions.shouldRestoreInstanceState()) {
if (r.isPersistable()) {
if (r.state != null || r.persistentState != null) {
mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,
r.persistentState);
}
} else if (r.state != null) {
mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
}
}
// Call postOnCreate()
// 调用Activity.onPostCreate()
if (pendingActions.shouldCallOnPostCreate()) {
activity.mCalled = false;
if (r.isPersistable()) {
mInstrumentation.callActivityOnPostCreate(activity, r.state,
r.persistentState);
} else {
mInstrumentation.callActivityOnPostCreate(activity, r.state);
}
if (!activity.mCalled) {
throw new SuperNotCalledException(
"Activity " + r.intent.getComponent().toShortString()
+ " did not call through to super.onPostCreate()");
}
}
// 让Activity中的DecorView可见
updateVisibility(r, true /* show */);
mSomeActivitiesChanged = true;
}
Activity#performStart()
final void performStart(String reason) {
// ...
// 间接调用onStart()
mInstrumentation.callActivityOnStart(this);
// ...
}
Activity#onPostCreate()
@CallSuper
protected void onPostCreate(@Nullable Bundle savedInstanceState) {
if (!isChild()) {
mTitleReady = true;
onTitleChanged(getTitle(), getTitleColor());
}
mCalled = true;
notifyContentCaptureManagerIfNeeded(CONTENT_CAPTURE_START);
}
- 这里需要注意，如果我们自定义的
XXXActivity是直接继承Activity的话，是没有subDecor的，这个subDecor就是在DecorView下又包装了一层View(ActionBarOverlayLayout)，如果是继承AppCompatActivity的话是有subDecor的
AppCompatActivity#onPostCreate()
AppComptActivity里使用AppCompatDelegate代理了基本所有的核心方法[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-817SCGnj-1665596202063)(C:\Users\Administrator\Desktop\appde.png)]
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
