ActivityManagerService是Android提供了管理Activity运行状态的系统进程，其实大家别被名字迷惑了，AMS（接下来都称ActivityManagerService为AMS）其实也兼任管理其他组件运行状态。
一、AMS概述
1.1 AMS启动流程
init进程是Android系统中的初始化进程，init生成Zygote进程，Android中大多数应用进程和系统进程都是通过Zygote进程生成的。
AMS这种系统级别的服务，一般都是在启动的时候触发，上面的流程详细地阐述了AMS的代码执行流程。由于本文并不是介绍Zygote的，所以这儿不作详细描述，可以参考一下我其他详述Zygote的文章。
AMS启动时的代码：
SystemServer.java
private void startBootstrapServices() {
//......
mActivityManagerService = mSystemServiceManager.startService(
ActivityManagerService.Lifecycle.class).getService();
mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
mActivityManagerService.setInstaller(installer);
//......
mActivityManagerService.setSystemProcess();
//......
}
其中获取AMS的地方有一点改动，去掉了AMS中的main(...)方法，将其中的工作移到AMS构造函数中。
ActivityManagerService.java
public static final class Lifecycle extends SystemService {
private final ActivityManagerService mService;
public Lifecycle(Context context) {
super(context);
mService = new ActivityManagerService(context);
}
@Override
public void onStart() {
mService.start();
}
@Override
public void onCleanupUser(int userId) {
mService.mBatteryStatsService.onCleanupUser(userId);
}
public ActivityManagerService getService() {
return mService;
}
}
1.2 AMS初始化工作
从上面AMS启动流程来看，AMS在在setSystemProcess()中注册的，注册的函数就是ServiceManager. addService(Context.ACTIVITY_SERVICE, this, true);从代码中看出来，AMS是一个实名的binder server，并且在AMS还注册了很多其他的服务，例如meminfo(这是内存使用情况的server)、cpuinfo(这是CPU使用情况的server)等等，这些服务在AMS中注册启用，说明这些服务会和AMS有很多交互。
ActivityManagerService.java
public void setSystemProcess() {
//......
ServiceManager.addService(Context.ACTIVITY_SERVICE, this, true);
ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);
ServiceManager.addService("meminfo", new MemBinder(this));
ServiceManager.addService("gfxinfo", new GraphicsBinder(this));
ServiceManager.addService("dbinfo", new DbBinder(this));
if (MONITOR_CPU_USAGE) {
ServiceManager.addService("cpuinfo", new CpuBinder(this));
}
ServiceManager.addService("permission", new PermissionController(this));
ServiceManager.addService("processinfo", new ProcessInfoService(this));
//......
}
我们查看一下AMS的构造做了什么事情，从代码中分段讲解AMS构造中要做的事情。
ActivityManagerService.java
public ActivityManagerService(Context systemContext) {
//......
//step1:
mSystemThread = ActivityThread.currentActivityThread();
mUiContext = mSystemThread.getSystemUiContext();
mPermissionReviewRequired = mContext.getResources().getBoolean(
com.android.internal.R.bool.config_permissionReviewRequired);
mHandlerThread = new ServiceThread(TAG,
THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
mHandlerThread.start();
mHandler = new MainHandler(mHandlerThread.getLooper());
mUiHandler = mInjector.getUiHandler(this);
mConstants = new ActivityManagerConstants(this, mHandler);
//......
//step2:
mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
"foreground", BROADCAST_FG_TIMEOUT, false);
mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
"background", BROADCAST_BG_TIMEOUT, true);
mBroadcastQueues[0] = mFgBroadcastQueue;
mBroadcastQueues[1] = mBgBroadcastQueue;
//step3:
mServices = new ActiveServices(this);
mProviderMap = new ProviderMap(this);
mAppErrors = new AppErrors(mUiContext, this);
//step4:
// TODO: Move creation of battery stats service outside of activity manager service.
File dataDir = Environment.getDataDirectory();
File systemDir = new File(dataDir, "system");
systemDir.mkdirs();
mBatteryStatsService = new BatteryStatsService(systemContext, systemDir, mHandler);
mBatteryStatsService.getActiveStatistics().readLocked();
mBatteryStatsService.scheduleWriteToDisk();
mOnBattery = DEBUG_POWER ? true
: mBatteryStatsService.getActiveStatistics().getIsOnBattery();
mBatteryStatsService.getActiveStatistics().setCallback(this);
mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));
mAppOpsService = mInjector.getAppOpsService(new File(systemDir, "appops.xml"), mHandler);
mAppOpsService.startWatchingMode(AppOpsManager.OP_RUN_IN_BACKGROUND, null,
new IAppOpsCallback.Stub() {
@Override public void opChanged(int op, int uid, String packageName) {
if (op == AppOpsManager.OP_RUN_IN_BACKGROUND && packageName != null) {
if (mAppOpsService.checkOperation(op, uid, packageName)
!= AppOpsManager.MODE_ALLOWED) {
runInBackgroundDisabled(uid);
}
}
}
});
mGrantFile = new AtomicFile(new File(systemDir, "urigrants.xml"));
mUserController = new UserController(this);
mVrController = new VrController(this);
GL_ES_VERSION = SystemProperties.getInt("ro.opengles.version",
ConfigurationInfo.GL_ES_VERSION_UNDEFINED);
if (SystemProperties.getInt("sys.use_fifo_ui", 0) != 0) {
mUseFifoUiScheduling = true;
}
//......
//step5:
mStackSupervisor = createStackSupervisor();
mStackSupervisor.onConfigurationChanged(mTempConfig);
mKeyguardController = mStackSupervisor.mKeyguardController;
mCompatModePackages = new CompatModePackages(this, systemDir, mHandler);
mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);
mTaskChangeNotificationController =
new TaskChangeNotificationController(this, mStackSupervisor, mHandler);
mActivityStarter = new ActivityStarter(this, mStackSupervisor);
mRecentTasks = new RecentTasks(this, mStackSupervisor);
//step6:
mProcessCpuThread = new Thread("CpuTracker") {
@Override
public void run() {
synchronized (mProcessCpuTracker) {
mProcessCpuInitLatch.countDown();
mProcessCpuTracker.init();
}
while (true) {
try {
try {
synchronized(this) {
final long now = SystemClock.uptimeMillis();
long nextCpuDelay = (mLastCpuTime.get()+MONITOR_CPU_MAX_TIME)-now;
long nextWriteDelay = (mLastWriteTime+BATTERY_STATS_TIME)-now;
//Slog.i(TAG, "Cpu delay=" + nextCpuDelay
// + ", write delay=" + nextWriteDelay);
if (nextWriteDelay < nextCpuDelay) {
nextCpuDelay = nextWriteDelay;
}
if (nextCpuDelay > 0) {
mProcessCpuMutexFree.set(true);
this.wait(nextCpuDelay);
}
}
} catch (InterruptedException e) {
}
updateCpuStatsNow();
} catch (Exception e) {
Slog.e(TAG, "Unexpected exception collecting process stats", e);
}
}
}
};
mHiddenApiBlacklist = new HiddenApiBlacklist(mHandler, mContext);
Watchdog.getInstance().addMonitor(this);
Watchdog.getInstance().addThread(mHandler);
}
通过分析上面的代码，将AMS的构造分为6个重要的步骤：
1.初始化构造AMS要用到的一些context和handler，例如mUiContext和mUiHandler配合使用，用于处理和UI显示相关的工作，mHandler是AMS中定义的用于分发AMS相关信息的处理器。
2.定义了容纳前台和后台的广播队列，这也说明了AMS不仅仅关注Activity，也负责其他组件状态的管理。
3.管理Service和Provider的对象数组。
4.初始化system下面需要的一系列文件目录。例如权限文件、进程状态信息文件等等。
5.这儿比较重要了，几个重要的变量需要关注一下，ActivityStackSupervisor(管理ActivityStack的重要类，这里面记录着activity状态信息，是AMS中的核心类), ActivityStarter(这是activity启动的处理类，这里管理者activity启动中用到的intent信息和flag标识，也和stack和task有重要的联系，下面会重点阐述)。
6.启动一个线程专门跟进cpu当前状态信息，AMS对当前cpu状态了如指掌，可以更加高效的安排其他工作。
二、Activity状态
2.1 Activity生命周期
Android入门必学的就是Android的四大组件，我们开发第一个app的时候，都会用到Activity，对于Activity的生命周期，大家应该已经烂熟于心了。下面是Activity生命周期状态图。
在这里我就不展开对生命周期的讨论了，这方面的文章还是很多的，我说一个比较重要的知识点吧，也是比较容易错的一个点，Android面试的时候，都会问这样一个问题：什么时候Activity对用户可见？这个问题相信大家都遇到过，之前看过的一些书都说是在执行onResume()的时候表明当前Activity已经可见了，这个回答可以说对，也可以说不对。因为执行onResume()的时候Activity确实可见了，但是只是这样回答不能让人满意，说明没有深入思考，也没有仔细查看源码。下面带大家看一下这一部分的源码：
ActivityThread.java
final void handleResumeActivity(IBinder token,
boolean clearHide, boolean isForward, boolean reallyResume, int seq, String reason) {
//......
// TODO Push resumeArgs into the activity for consideration
r = performResumeActivity(token, clearHide, reason);
if (r != null) {
//......
boolean willBeVisible = !a.mStartedActivity;
if (!willBeVisible) {
try {
willBeVisible = ActivityManager.getService().willActivityBeVisible(
a.getActivityToken());
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
if (r.window == null && !a.mFinished && willBeVisible) {
r.window = r.activity.getWindow();
View decor = r.window.getDecorView();
decor.setVisibility(View.INVISIBLE);
ViewManager wm = a.getWindowManager();
WindowManager.LayoutParams l = r.window.getAttributes();
a.mDecor = decor;
l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
l.softInputMode |= forwardBit;
//......
if (a.mVisibleFromClient) {
if (!a.mWindowAdded) {
a.mWindowAdded = true;
wm.addView(decor, l);
}
//......
}
// If the window has already been added, but during resume
// we started another activity, then don't yet make the
// window visible.
} else if (!willBeVisible) {
if (localLOGV) Slog.v(
TAG, "Launch " + r + " mStartedActivity set");
r.hideForNow = true;
}
// Get rid of anything left hanging around.
cleanUpPendingRemoveWindows(r, false /* force */);
// The window is now visible if it has been added, we are not
// simply finishing, and we are not starting another activity.
if (!r.activity.mFinished && willBeVisible
&& r.activity.mDecor != null && !r.hideForNow) {
//......
if (r.activity.mVisibleFromClient) {
r.activity.makeVisible();
}
}
//......
}
//......
}
此函数是handleResumeActivity(...)，从字面上看应该是和onResume相关，在此函数中有执行activity.makeVisible()，这个makeVisible就是当前Activity可见的执行函数，所以严格来讲，不能说onResume是让Activity可见的，这点关系要搞清楚。下面Activity处理流程中详细画出了当前的Activity状态的时序图，里面也写明了Activity可见的调用时机。
Android生命周期都是在UI线程中运行的，所以在这里面执行的代码都不能有过分耗时的情况，否则会发生ANR等问题，这个需要平时开发的时候养成良好的习惯。Android的生命周期是系统给开发者提供的一个体现当前Activity所处状态的外在体现，掌握这些生命周期，不能仅仅停留在表面的认识上，还应该知道深层的调用规律和调用逻辑。
2.2 Activity状态管理
Android是如何管理Activity状态的，我们平时在Android开发中用到的intent flags taskAffinity launchMode是如何管理的，一个Task包含一个或者多个Activity，一个Stack包含一个或者多个Task，这儿引入ActivityStack，还有ActivityStackSupervisor负责管理所有的Stack。那么Activity是如何创建并且如何管理的？
2.2.1 ActivityStack创建
从ActivityStack创建的过程中也能看出来，ActivityStackSupervisor是管理ActivityStack的重要类，操作ActivityStack，都通过ActivityStackSupervisor衍生一个接口来执行。
ActivityStackSupervisor.java
void setWindowManager(WindowManagerService wm) {
synchronized (mService) {
//......
mHomeStack = mFocusedStack = mLastFocusedStack =
getStack(HOME_STACK_ID, CREATE_IF_NEEDED, ON_TOP);
//......
}
}
protected T getStack(int stackId, boolean createStaticStackIfNeeded,
boolean createOnTop) {
final ActivityStack stack = mStacks.get(stackId);
if (stack != null) {
return (T) stack;
}
if (!createStaticStackIfNeeded || !StackId.isStaticStack(stackId)) {
return null;
}
if (stackId == DOCKED_STACK_ID) {
// Make sure recents stack exist when creating a dock stack as it normally need to be on
// the other side of the docked stack and we make visibility decisions based on that.
getStack(RECENTS_STACK_ID, CREATE_IF_NEEDED, createOnTop);
}
return (T) createStackOnDisplay(stackId, DEFAULT_DISPLAY, createOnTop);
}
ActivityStack createStackOnDisplay(int stackId, int displayId, boolean onTop) {
final ActivityDisplay activityDisplay = getActivityDisplayOrCreateLocked(displayId);
if (activityDisplay == null) {
return null;
}
return createStack(stackId, activityDisplay, onTop);
}
ActivityStack createStack(int stackId, ActivityDisplay display, boolean onTop) {
switch (stackId) {
case PINNED_STACK_ID:
return new PinnedActivityStack(display, stackId, this, mRecentTasks, onTop);
default:
return new ActivityStack(display, stackId, this, mRecentTasks, onTop);
}
}
初始化创建了mHomeStack(包含launcher app)、mFocusStack(接收当前即将启动的Activity)、mLastFocusedStack(接收上次启动的Activity)，从代码中更好理解这些概念，下面ActivityStack分析会详细讨论这3个stack的调用时机。
2.2.1 ActivityStack概述
ActivityStack详细分析会在下一张讲解。本文只是简单介绍一下ActivityStack中常用的变量，这些变量对理解ActivityStack的功能有很大的帮助。
1.定义ActivityState
ActivityStack.java
enum ActivityState {
INITIALIZING,
RESUMED,
PAUSING,
PAUSED,
STOPPING,
STOPPED,
FINISHING,
DESTROYING,
DESTROYED
}
2.特殊状态下的Activity
ActivityStack
ActivityRecord mPausingActivity = null;
ActivityRecord mLastPausedActivity = null;
ActivityRecord mLastNoHistoryActivity = null;
ActivityRecord mResumedActivity = null;
mPausingActivity表示正在被暂停的Activity
mLastPausedActivity 表示上一个被暂停的Activity
mLastNoHistoryActivity 表示上一个设置为FLAG_ACTIVITY_NO_HISTORY的Activity
mResumedActivity 表示当前处于恢复状态的Activity
3.全局的ArrayList
ActivityStack.java
private final ArrayList mTaskHistory = new ArrayList<>();
final ArrayList mLRUActivities = new ArrayList<>();
final ArrayList mNoAnimActivities = new ArrayList<>();
mTaskHistory 记录所有的Activity信息
mLRUActivities 按照最近最少使用排序的Activity集合
mNoAnimActivities 不考虑状态迁移动画的Activity集合
三、Activity处理流程
3.1 startActivity流程
启动一个Activity之后经历的流程如图所示，这儿写明了回调各个流程的时机，其中包含这对Activity状态的处理，这一点非常重要，Android系统处理的Activity很多，我们准确指示当前Activity的状态，可以保证Activity调用的正确性。由于onPause()触发条件比较多，这边没有列出onPause()的回调流程，感兴趣的同学可以自己查看一下源码，学习一下具体的流程，但是Activity生命周期的核心要点都在onCreate() onStart() onResume()上面，其他的生命周期其实就是对Activity状态的维护。
应用程序的入口在什么地方？这也是面试中经常问到的问题，别告诉我你想回答是Activity.onCreate(...)，那显然大错特错，所谓应用程序的入口，就是当前的应用程序所在的进程是什么时候被启动的，这才是关键。解答这个问题，不看源码，很难问答，如果只是对Activity生命周期有一个表象的认识，显然不太够。这里列出关键的地方，抛砖引玉。
ActivityStackSupervisor.java
void startSpecificActivityLocked(ActivityRecord r,
boolean andResume, boolean checkConfig) {
// Is this activity's application already running?
ProcessRecord app = mService.getProcessRecordLocked(r.processName,
r.info.applicationInfo.uid, true);
r.getStack().setLaunchTime(r);
//step1:
if (app != null && app.thread != null) {
try {
if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0
|| !"android".equals(r.info.packageName)) {
// Don't add this if it is a platform component that is marked
// to run in multiple processes, because this is actually
// part of the framework so doesn't make sense to track as a
// separate apk in the process.
app.addPackage(r.info.packageName, r.info.applicationInfo.versionCode,
mService.mProcessStats);
}
realStartActivityLocked(r, app, andResume, checkConfig);
return;
} catch (RemoteException e) {
Slog.w(TAG, "Exception when starting activity "
+ r.intent.getComponent().flattenToShortString(), e);
}
// If a dead object exception was thrown -- fall through to
// restart the application.
}
//step2:
mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
"activity", r.intent.getComponent(), false, false, true);
}
上面标注了step1和step2，从step1的判断来看if (app != null && app.thread != null)，说明当前的Activity所在的进程存在的话，执行realStartActivityLocked(...)，那么step2执行的条件显然就是当前Activity所在的进程不存在的情况了。继续看下去。
很显然，ActivityThread->main(...)才是应用程序真正的启动入口。仔细阅读源码能帮助我们什么？能帮助我们透过现象看本质。