Android Activity的生命周期是Android应用开发中的一个核心概念，它描述了Activity从创建到销毁所经历的不同状态。
onCreate()：当Activity第一次被创建时调用,这是Activity生命周期的第一个回调方法。
onStart()：Activity对用户可见时调用。此时Activity虽然可见，但还不能与用户交互。可以在此阶段进行一些动画效果的初始化或准备工作。
onResume()：Activity获取焦点，可以与用户交互时调用。此时Activity处于前台运行状态。在此阶段，Activity可以响应用户的输入和操作。
onPause()：Activity失去焦点，但仍对用户可见时调用。例如，当新的Activity或对话框出现时。在此方法中，应保存关键数据和执行轻量级的资源释放操作，以应对Activity可能被随时销毁的情况。
onStop()：Activity不再对用户可见时调用。此时Activity虽然保留在内存中，但不再显示。执行更重量级的资源释放操作，如断开数据库连接、停止动画等。
onDestroy()：Activity被销毁时调用。此时Activity将释放所有占用的资源。清理Activity中使用的所有资源，避免内存泄漏。
onRestart()：Activity在停止状态下重新变为可见时调用。例如，用户从后台返回到该Activity。重新获取Activity的状态和资源，准备与用户交互。
本文以Android 13代码对例对Activity生命周期进行梳理。
1，在frameworks/base/core/java/android/app/ClientTransactionHandler.java中
public abstract class ClientTransactionHandler {
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);//在ActivityThread类中定义有class H extends Handler
}
}
上面的代码发送EXECUTE_TRANSACTION消息。
2，在frameworks/base/core/java/android/app/ActivityThread.java中
private final TransactionExecutor mTransactionExecutor = new TransactionExecutor(this);
public void handleMessage(Message msg) {
switch (msg.what) {
case EXECUTE_TRANSACTION:
final ClientTransaction transaction = (ClientTransaction) msg.obj;
mTransactionExecutor.execute(transaction);//调用TransactionExecutor类的execute函数
break;
}
}
3,在frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java中
public class TransactionExecutor {
public void execute(ClientTransaction transaction) {
executeCallbacks(transaction);//调用TransactionExecutor类的executeCallbacks函数
executeLifecycleState(transaction); //调用executeLifecycleState函数
}
private void executeLifecycleState(ClientTransaction transaction) {
final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest(); //获取当前事务中的生命周期状态请求
// Cycle to the state right before the final requested state.
//通过cycleToPath(r, lifecycleItem.getTargetState(), true, transaction);方法，将Activity的状态变更到最终请求状态之前的状态。
//这里的逻辑是为了确保Activity按照正确的顺序通过生命周期的各个状态，excludeLastState参数为真表示排除最终请求的状态本身，只到达其前一个状态。
cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */, transaction); //调用cycleToPath方法
// Execute the final transition with proper parameters.
//通过lifecycleItem.execute(mTransactionHandler, token, mPendingActions);执行最终的生命周期转换。这一步会根据lifecycleItem中包含的指令（如启动、暂停、恢复等）来更新Activity的状态。
lifecycleItem.execute(mTransactionHandler, token, mPendingActions); //有StartActivityItem,StopActivityItem,DestroyActivityItem,ResumeActivityItem,PauseActivityItem等类文件继承自ActivityLifecycleItem.java，执行execute函数。
lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);//通过lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);执行生命周期转换后的后续操作。这可能包括清理资源、更新UI等。
}
@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); //调用performLifecycleSequence方法
}
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,
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);
}
}
}
}
在上面的performLifecycleSequence函数中，对应不同的生命周期状态，调用不同的函数处理。在函数cycleToPath中调用TransactionExecutorHelper.java类的getLifecyclePath函数来获取生命周期状态序列。
4,在frameworks/base/core/java/android/app/servertransaction/TransactionExecutorHelper.java中
public class TransactionExecutorHelper {
public IntArray getLifecyclePath(int start, int finish, boolean excludeLastState) {
mLifecycleSequence.clear(); //清除之前可能存在的生命周期序列
if (finish >= start) {
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); //对于从ON_START到ON_STOP的转换，由于Activity在ON_STOP时不会经过ON_RESUME和ON_PAUSE，所以直接添加ON_STOP。
} else {
// just go there
for (int i = start + 1; i <= finish; i++) { //通过循环将需要经过的生命周期状态添加到mLifecycleSequence中
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); //如果需要从ON_PAUSE直接转换到ON_RESUME（这通常不是正常流程，但这里作为特殊情况处理），则直接添加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);
}
}
}
return mLifecycleSequence; //返回构建好的生命周期状态序列
}
}
5，在frameworks/base/core/java/android/app/ClientTransactionHandler.java中
public abstract class ClientTransactionHandler {
/** Perform activity launch. */
public abstract Activity handleLaunchActivity(@NonNull ActivityClientRecord r,PendingTransactionActions pendingActions, Intent customIntent);
/** Perform activity start. */
public abstract void handleStartActivity(@NonNull ActivityClientRecord r,PendingTransactionActions pendingActions, ActivityOptions activityOptions);
...
}
上面的代码定义了一系列生命周期的处理函数。ClientTransactionHandler.java为抽象类，ActivityThread继承自ClientTransactionHandler类。即public final class ActivityThread extends ClientTransactionHandler。
6，在frameworks/base/core/java/android/app/ActivityThread.java中
public final class ActivityThread extends ClientTransactionHandler implements ActivityThreadInternal {
public Activity handleLaunchActivity(ActivityClientRecord r,PendingTransactionActions pendingActions, Intent customIntent) {
final Activity a = performLaunchActivity(r, customIntent);
return a;
}
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
java.lang.ClassLoader cl = appContext.getClassLoader();
activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);//创建新的activity
activity.attach(...); //attach 方法中主要做了初始化 PhoneWindow 的一些操作
r.activity = activity;
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
return activity;
}
public void handleStartActivity(ActivityClientRecord r,PendingTransactionActions pendingActions, ActivityOptions activityOptions) {
final Activity activity = r.activity;
// Start
activity.performStart("handleStartActivity"); //调用performStart函数
r.setState(ON_START); //将ActivityClientRecord的状态更新为ON_START，表示Activity现在处于onStart阶段
updateVisibility(r, true /* show */); //调用updateVisibility来更新Activity的可见性
mSomeActivitiesChanged = true;
}
}
上面的代码中：对于handleLaunchActivity，会通过performLaunchActivity进一步调用到Instrumentation.java类的callActivityOnCreate函数。对于handleStartActivity，会直接调用到Activity类的performStart函数。
7,在frameworks/base/core/java/android/app/Instrumentation.java中
public class Instrumentation {
public void callActivityOnCreate(Activity activity, Bundle icicle,PersistableBundle persistentState) {
prePerformCreate(activity);
activity.performCreate(icicle, persistentState); // 调用performCreate函数
postPerformCreate(activity);
}
public void callActivityOnStart(Activity activity) {
activity.onStart(); //调用activity的onStart函数
}
}
8，在frameworks/base/core/java/android/app/Activity.java中
public class Activity extends ContextThemeWrapper implements LayoutInflater.Factory2,Window.Callback, KeyEvent.Callback,OnCreateContextMenuListener, ComponentCallbacks2,
Window.OnWindowDismissedCallback,ContentCaptureManager.ContentCaptureClient {
final void performCreate(Bundle icicle) {
performCreate(icicle, null);
}
final void performCreate(Bundle icicle, PersistableBundle persistentState) {
if (persistentState != null) {
onCreate(icicle, persistentState); // 调用onCreate函数
} else {
onCreate(icicle);
}
}
final void performStart(String reason) {
mInstrumentation.callActivityOnStart(this); //调用callActivityOnStart
mFragments.dispatchStart();
mFragments.reportLoaderStart();
}
}
9，在frameworks/base/core/java/android/app/Application.java中
public class Application extends ContextWrapper implements ComponentCallbacks2 {
private ArrayList<ActivityLifecycleCallbacks> mActivityLifecycleCallbacks = new ArrayList<ActivityLifecycleCallbacks>();
public interface ActivityLifecycleCallbacks {
void onActivityCreated(@NonNull Activity activity, @Nullable Bundle savedInstanceState);
void onActivityStarted(@NonNull Activity activity);
void onActivityResumed(@NonNull Activity activity);
void onActivityPaused(@NonNull Activity activity);
void onActivityStopped(@NonNull Activity activity);
void onActivityDestroyed(@NonNull Activity activity);
}
public void registerActivityLifecycleCallbacks(ActivityLifecycleCallbacks callback) {
synchronized (mActivityLifecycleCallbacks) {
mActivityLifecycleCallbacks.add(callback);
}
}
public void unregisterActivityLifecycleCallbacks(ActivityLifecycleCallbacks callback) {
synchronized (mActivityLifecycleCallbacks) {
mActivityLifecycleCallbacks.remove(callback);
}
}
/* package */ void dispatchActivityCreated(@NonNull Activity activity,
@Nullable Bundle savedInstanceState) {
Object[] callbacks = collectActivityLifecycleCallbacks();
if (callbacks != null) {
for (int i=0; i<callbacks.length; i++) {
((ActivityLifecycleCallbacks)callbacks[i]).onActivityCreated(activity,
savedInstanceState);
}
}
}
/* package */ void dispatchActivityStarted(@NonNull Activity activity) {
Object[] callbacks = collectActivityLifecycleCallbacks();
if (callbacks != null) {
for (int i=0; i<callbacks.length; i++) {
((ActivityLifecycleCallbacks)callbacks[i]).onActivityStarted(activity);
}
}
}
}
在上面的代码中，registerActivityLifecycleCallbacks用来对应用的Activity的生命周期进行集中管理。
可以在application中ActivityLifecycleCallbacks lifecycleCallbacks = new ActivityLifecycleCallbacks() {...}; registerActivityLifecycleCallbacks(lifecycleCallbacks);
10，在frameworks/base/core/java/android/app/Activity.java中
public class Activity extends ContextThemeWrapper implements LayoutInflater.Factory2,Window.Callback, KeyEvent.Callback,OnCreateContextMenuListener, ComponentCallbacks2,
Window.OnWindowDismissedCallback,ContentCaptureManager.ContentCaptureClient {
private final ArrayList<Application.ActivityLifecycleCallbacks> mActivityLifecycleCallbacks = new ArrayList<Application.ActivityLifecycleCallbacks>();
public void registerActivityLifecycleCallbacks(@NonNull Application.ActivityLifecycleCallbacks callback) {
synchronized (mActivityLifecycleCallbacks) {
mActivityLifecycleCallbacks.add(callback);
}
}
public void unregisterActivityLifecycleCallbacks(@NonNull Application.ActivityLifecycleCallbacks callback) {
synchronized (mActivityLifecycleCallbacks) {
mActivityLifecycleCallbacks.remove(callback);
}
}
protected void onCreate(@Nullable Bundle savedInstanceState) {
dispatchActivityCreated(savedInstanceState);
}
private void dispatchActivityCreated(@Nullable Bundle savedInstanceState) {
getApplication().dispatchActivityCreated(this, savedInstanceState);
Object[] callbacks = collectActivityLifecycleCallbacks();
if (callbacks != null) {
for (int i = 0; i < callbacks.length; i++) {
((Application.ActivityLifecycleCallbacks) callbacks[i]).onActivityCreated(this,
savedInstanceState);
}
}
}
protected void onStart() {
dispatchActivityStarted();
}
private void dispatchActivityStarted() {
getApplication().dispatchActivityStarted(this);
}
}
上面的代码中，在activity的每个生命周期执行之后都会执行对应生命周期的回调接口，比如onCreate函数调用dispatchActivityCreated，onStart函数调用dispatchActivityStarted等。
