1-主要介绍activity 生命周期
本文主要介绍 从一个activity 跳转到另外一个activity 机制
1:MainActivity--->SecondActivity
2:SecondActivity-->MainActivity
启动阶段
08-14 10:52:26.519 28194 28194 I MainActivity: helloworld-------onCreate
08-14 10:52:26.521 28194 28194 I MainActivity: helloworld-------onStart
08-14 10:52:26.523 28194 28194 I MainActivity: helloworld---finsh----onResume
1.1:MainActivity--->SecondActivity
08-14 10:56:33.518 28194 28194 I MainActivity: helloworld------sleep-100
08-14 10:56:33.518 28194 28194 I MainActivity: helloworld-------onPause, isfinish=false
08-14 10:56:33.545 28194 28194 I SecondActivity: helloworld-------onCreate
08-14 10:56:33.546 28194 28194 I SecondActivity: helloworld-------onStart
08-14 10:56:33.548 28194 28194 I SecondActivity: helloworld---finsh----onResume
08-14 10:56:33.985 28194 28194 I MainActivity: helloworld-------onSaveInstanceState
08-14 10:56:33.993 28194 28194 I MainActivity: helloworld---finsh----onStop
1.2:SecondActivity-->MainActivity
08-14 10:58:35.166 28194 28194 I SecondActivity: helloworld------sleep-100
08-14 10:58:35.166 28194 28194 I SecondActivity: helloworld-------onPause, isfinish=false
08-14 10:58:35.193 28194 28194 I MainActivity: helloworld-------onCreate
08-14 10:58:35.194 28194 28194 I MainActivity: helloworld-------onStart
08-14 10:58:35.196 28194 28194 I MainActivity: helloworld---finsh----onResume
08-14 10:58:35.622 28194 28194 I SecondActivity: helloworld-------onSaveInstanceState
08-14 10:58:35.628 28194 28194 I SecondActivity: helloworld---finsh----onStop
使用时候的界面：
github: source code
Activity-life-cycle
备注加深：
Activity的启动模式有四种：standard、singleTop、singleTask和singleInstance。
四种模式的修改都可以在AandroidManifest.xml
example:android:launchMode="singleTop"
2-启动模式介绍
- 一个ActivityRecord对应一个Activity，保存了一个Activity的所有信息;但是一个Activity可能会有多个* ActivityRecord,因为Activity可以被多次启动，这个主要取决于其启动模式。
- 一个TaskRecord由一个或者多个ActivityRecord组成，这就是我们常说的任务栈，具有后进先出的特点。
- ActivityStack则是用来管理TaskRecord的，包含了多个TaskRecord。
代码分析
2.1ActivityRecord
frameworks/base/services/core/java/com/android/server/am/ActivityRecord.java
final class ActivityRecord extends ConfigurationContainer implements AppWindowContainerListener {
final ActivityManagerService service; // owner
final IApplicationToken.Stub appToken; // window manager token
AppWindowContainerController mWindowContainerController;
final ActivityInfo info; // all about me
final ApplicationInfo appInfo; // information about activity's app
//省略其他成员变量
//ActivityRecord所在的TaskRecord
private TaskRecord task; // the task this is in.
//构造方法，需要传递大量信息
ActivityRecord(ActivityManagerService _service, ProcessRecord _caller, int _launchedFromPid,
int _launchedFromUid, String _launchedFromPackage, Intent _intent, String _resolvedType,
ActivityInfo aInfo, Configuration _configuration,
com.android.server.am.ActivityRecord _resultTo, String _resultWho, int _reqCode,
boolean _componentSpecified, boolean _rootVoiceInteraction,
ActivityStackSupervisor supervisor, ActivityOptions options,
com.android.server.am.ActivityRecord sourceRecord) {
}
}
实际上，ActivityRecord中存在着大量的成员变量，包含了一个Activity的所有信息。
ActivityRecord中的成员变量task表示其所在的TaskRecord，由此可以看出：ActivityRecord与TaskRecord建立了联系。
frameworks/base/services/core/java/com/android/server/am/ActivityStarter.java
startActivity()时会创建一个ActivityRecord与一个TaskRecord：
class ActivityStarter {
private int startActivity(IApplicationThread caller, Intent intent, Intent ephemeralIntent,
String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,
String callingPackage, int realCallingPid, int realCallingUid, int startFlags,
ActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified,
com.android.server.am.ActivityRecord[] outActivity, TaskRecord inTask) {
//其他代码略
ActivityRecord r = new ActivityRecord(mService, callerApp, callingPid, callingUid,
callingPackage, intent, resolvedType, aInfo, mService.getGlobalConfiguration(),
resultRecord, resultWho, requestCode, componentSpecified, voiceSession != null,
mSupervisor, options, sourceRecord);
//其他代码略
}
}
2.2 TaskRecord
frameworks/base/services/core/java/com/android/server/am/TaskRecord.java
TaskRecord，内部维护一个ArrayList
final class TaskRecord extends ConfigurationContainer implements TaskWindowContainerListener {
final int taskId; //任务ID
final ArrayList mActivities; //使用一个ArrayList来保存所有的ActivityRecord
private ActivityStack mStack; //TaskRecord所在的ActivityStack
//构造方法
TaskRecord(ActivityManagerService service, int _taskId, ActivityInfo info, Intent _intent,
IVoiceInteractionSession _voiceSession, IVoiceInteractor _voiceInteractor, int type) {
}
//添加Activity到顶部
void addActivityToTop(com.android.server.am.ActivityRecord r) {
addActivityAtIndex(mActivities.size(), r);
}
//添加Activity到指定的索引位置
void addActivityAtIndex(int index, ActivityRecord r) {
//...
r.setTask(this);//为ActivityRecord设置TaskRecord，就是这里建立的联系
//...
index = Math.min(size, index);
mActivities.add(index, r);//添加到mActivities
//...
}
//其他代码略
}
可以看到TaskRecord中使用了一个ArrayList来保存所有的ActivityRecord。
同样，TaskRecord中的mStack表示其所在的ActivityStack。
frameworks/base/services/core/java/com/android/server/am/ActivityStarter.java
startActivity()时也会创建一个TaskRecord：
class ActivityStarter {
private int setTaskFromReuseOrCreateNewTask(TaskRecord taskToAffiliate, int preferredLaunchStackId, ActivityStack topStack) {
mTargetStack = computeStackFocus(mStartActivity, true, mLaunchBounds, mLaunchFlags, mOptions);
if (mReuseTask == null) {
//创建一个createTaskRecord，实际上是调用ActivityStack里面的createTaskRecord（）方法，ActivityStack下面会讲到
final TaskRecord task = mTargetStack.createTaskRecord(
mSupervisor.getNextTaskIdForUserLocked(mStartActivity.userId),
mNewTaskInfo != null ? mNewTaskInfo : mStartActivity.info,
mNewTaskIntent != null ? mNewTaskIntent : mIntent, mVoiceSession,
mVoiceInteractor, !mLaunchTaskBehind /* toTop */, mStartActivity.mActivityType);
//其他代码略
}
}
}
2.3 ActivityStack
ActivityStack,内部维护了一个ArrayList
frameworks/base/services/core/java/com/android/server/am/ActivityStack.java
class ActivityStack extends ConfigurationContainer implements StackWindowListener {
private final ArrayList mTaskHistory = new ArrayList<>();//使用一个ArrayList来保存TaskRecord
final int mStackId;
protected final ActivityStackSupervisor mStackSupervisor;//持有一个ActivityStackSupervisor，所有的运行中的ActivityStacks都通过它来进行管理
//构造方法
ActivityStack(ActivityStackSupervisor.ActivityDisplay display, int stackId,
ActivityStackSupervisor supervisor, RecentTasks recentTasks, boolean onTop) {
}
TaskRecord createTaskRecord(int taskId, ActivityInfo info, Intent intent,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
boolean toTop, int type) {
//创建一个task
TaskRecord task = new TaskRecord(mService, taskId, info, intent, voiceSession, voiceInteractor, type);
//将task添加到ActivityStack中去
addTask(task, toTop, "createTaskRecord");
//其他代码略
return task;
}
//添加Task
void addTask(final TaskRecord task, final boolean toTop, String reason) {
addTask(task, toTop ? MAX_VALUE : 0, true /* schedulePictureInPictureModeChange */, reason);
//其他代码略
}
//添加Task到指定位置
void addTask(final TaskRecord task, int position, boolean schedulePictureInPictureModeChange,
String reason) {
mTaskHistory.remove(task);//若存在，先移除
//...
mTaskHistory.add(position, task);//添加task到mTaskHistory
task.setStack(this);//为TaskRecord设置ActivityStack
//...
}
//其他代码略
}
- 可以看到ActivityStack使用了一个ArrayList来保存TaskRecord。
- 另外，ActivityStack中还持有ActivityStackSupervisor对象，这个是用来管理ActivityStacks的。
ActivityStack是由ActivityStackSupervisor来创建的，实际ActivityStackSupervisor就是用来管理ActivityStack的，继续看下面的ActivityStackSupervisor分析。
frameworks/base/services/core/java/com/android/server/am/ActivityStackSupervisor.java
ActivityStackSupervisor
public class ActivityStackSupervisor extends ConfigurationContainer implements DisplayListener {
ActivityStack mHomeStack;//管理的是Launcher相关的任务
ActivityStack mFocusedStack;//管理非Launcher相关的任务
//创建ActivityStack
ActivityStack createStack(int stackId, ActivityStackSupervisor.ActivityDisplay display, boolean onTop) {
switch (stackId) {
case PINNED_STACK_ID:
//PinnedActivityStack是ActivityStack的子类
return new PinnedActivityStack(display, stackId, this, mRecentTasks, onTop);
default:
//创建一个ActivityStack
return new ActivityStack(display, stackId, this, mRecentTasks, onTop);
}
}
}
- ActivityStackSupervisor内部有两个不同的ActivityStack对象：mHomeStack、mFocusedStack，用来管理不同的任务。
- ActivityStackSupervisor内部包含了创建ActivityStack对象的方法。
AMS初始化时会创建一个ActivityStackSupervisor对象。
因此ActivityRecord、TaskRecord、ActivityStack 之间的关系：
3-场景分析
adb shell dumpsys activity
ACTIVITY MANAGER ACTIVITIES (dumpsys activity activities)
Display #0 (activities from top to bottom):
Stack #0:
//中间省略其他...
Task id #102
//中间省略其他...
TaskRecord{446ae9e #102 I=com.google.android.apps.nexuslauncher/.NexusLauncherActivity U=0 StackId=0 sz=1}
Intent { act=android.intent.action.MAIN cat=[android.intent.category.HOME] flg=0x10000100 cmp=com.google.android.apps.nexuslauncher/.NexusLauncherActivity }
Hist #0: ActivityRecord{54fa22 u0 com.google.android.apps.nexuslauncher/.NexusLauncherActivity t102}
Intent { act=android.intent.action.MAIN cat=[android.intent.category.HOME] flg=0x10000100 cmp=com.google.android.apps.nexuslauncher/.NexusLauncherActivity }
ProcessRecord{19c7c43 2203:com.google.android.apps.nexuslauncher/u0a22}
Running activities (most recent first):
TaskRecord{446ae9e #102 I=com.google.android.apps.nexuslauncher/.NexusLauncherActivity U=0 StackId=0 sz=1}
Run #0: ActivityRecord{54fa22 u0 com.google.android.apps.nexuslauncher/.NexusLauncherActivity t102}
mResumedActivity: ActivityRecord{54fa22 u0 com.google.android.apps.nexuslauncher/.NexusLauncherActivity t102}
//省略其他
实际上就是如下图所示的结构，这里的Stack #0就是ActivityStackSupervisor中的mHomeStack，mHomeStack管理的是Launcher相关的任务。
3.1 从桌面启动一个Activity
从桌面点击图标启动一个AActivity，可以看到，会多了一个Stack #1，这个Stack #1就是ActivityStackSupervisor中的mFocusedStack，mFocusedStack负责管理的是非Launcher相关的任务。同时也会创建一个新的ActivityRecord和TaskRecord，ActivityRecord放到TaskRecord中，TaskRecord则放进mFocusedStack中。
3.2 默认模式从A启动B
然后，我们从AActivity中启动一个BActivity,可以看到会创建一个新的ActivityRecord然后放到已有的TaskRecord栈顶。
3.3 从A启动B创建新栈
如果我们想启动的BActivity在一个新的栈中呢，我们可以用singleInstance的方式来启动BActivity。singleInstance后面也会讲到。这种方式会创建一个新的ActivityRecord和TaskRecord，把ActivityRecord放到新的TaskRecord中去。
3.4启动流程图
这里对启动Activity过程中涉及到的ActivityStack、TaskRecord、ActivityRecord、ActivityStackSupervisor进行简单的分析，实际上一张时序图就可以看明白了。相关的代码可以看上面的内容。
简单总结：
- startActivity时首先会创建一个ActivityRecord。
- 如果有需要，会创建一个TaskRecord，并把这个TaskRecord加入到ActivityStack中。
- 将ActivityRecord添加到TaskRecord的栈顶。
4-启动模式
4.1-standerd
默认模式，每次启动Activity都会创建一个新的Activity实例。
4.2 singleTop
如果要启动的Activity已经在栈顶，则不会重新创建Activity，只会调用该该Activity的onNewIntent()方法。
如果要启动的Activity不在栈顶，则会重新创建该Activity的实例。
比如：现在有个A Activity,我们在A以standerd模式上面启动B，然后在B上面以singleTop模式启动A，其过程如图所示，这里会新创建一个A实例：
如果在B上面以singleTop模式启动B的话，则不会重新创建B，只会调用onNewIntent()方法，其过程如图所示：
4.3 singleTask
如果要启动的Activity已经存在于它想要归属的栈中，那么不会创建该Activity实例，将栈中位于该Activity上的所有的Activity出栈，同时该Activity的onNewIntent()方法会被调用。
如果要启动的Activity不存在于它想要归属的栈中，并且该栈存在，则会创建该Activity的实例。
如果要启动的Activity想要归属的栈不存在，则首先要创建一个新栈，然后创建该Activity实例并压入到新栈中
比如：现在有个A Activity，我们在A以standerd模式上面启动B，然后在B上面以singleTask模式启动A，其过程如图所示：
4.4 -singleInstance
基本和singleTask一样，不同的是启动Activity时，首先要创建在一个新栈，然后创建该Activity实例并压入新栈中，新栈中只会存在这一个Activity实例。
比如：现在有个A Activity,我们在A以singleInstance模式上面启动B，其过程如图所示：
5 Intent的FLAG
另外，如果startActivity()时往Intent 中加入相应的标志来指定启动模式，这种方式的优先级会比在AndroidManifest中定义的优先级高;但是AndroidManifest中只能定义四种启动方式：standard、singleTop、singleTask、singleInstance，而Intent的flag则有很多种。具体的可以看看文档，我们这里看看部分flag：
- FLAG_ACTIVITY_NEW_TASK ：跟launchMode中的singleTask一样。
- FLAG_ACTIVITY_SINGLE_TOP ：跟launchMode中的singleTop一样。
- FLAG_ACTIVITY_CLEAR_TOP ：launchMode中没有对应的值，如果要启动的Activity已经存在于栈中，则将所有位于它上面的Activity出栈。singleTask默认具有此标记位的效果。
6 其他调试信息
对与上面的理解可以，在https://github.com/wangxuefeng123/helloworld-activity-life.git 下载 调试code, 上面的code 比较简单，就是跳转
如果对onCreate, onDestory 进行关注，添加下面log 进行调试
Log.i(tag, "helloworld-----onCreate:"+MainActivity.this.toString());
lunch-mode的修改并不是都有效果，具体平台还要调试，具体看看系统如何走的。
REF:
https://www.jianshu.com/p/103ab3830bc1
https://www.jianshu.com/p/94816e52cd77