【吃透源码系列】之AMS

ActivityManagerService（AMS）是 Android 框架层最核心的系统服务，是整个 Android 组件管理、进程调度和应用生命周期的大总管。本文基于 Android 10 (API 29) / Android 11 (API 30) 的 AOSP 源码，深入分析 AMS 的体系结构、启动流程、核心数据结构和关键运行机制。

一、AMS 的体系定位

1.1 AMS 在系统架构中的位置

AMS 运行在 system_server 进程中，以 Java 对象的形态存在，但它同时通过 Binder 向外界暴露 IActivityManager 接口。所有第三方应用进程通过 ActivityManager（封装了 Binder 代理）与 AMS 通信。

┌─────────────────────────────────────────────────────────┐
│                    App Process                          │
│  ┌──────────┐  ┌──────────────┐  ┌──────────────────┐  │
│  │ Activity │  │ActivityThread│  │ ActivityManager  │  │
│  │          │→ │              │→ │ (Binder Proxy)   │  │
│  └──────────┘  └──────────────┘  └────────┬─────────┘  │
│                                           │ Binder IPC │
└───────────────────────────────────────────┼─────────────┘
                                            │
┌───────────────────────────────────────────┼─────────────┐
│                  system_server            │             │
│  ┌────────────────────────────────────────▼──────────┐  │
│  │             ActivityManagerService                │  │
│  │  ┌─────────────┐  ┌──────────────┐  ┌─────────┐  │  │
│  │  │ActivityStarter│  │ATMS(Android10+)│  │ OomAdj │  │  │
│  │  └─────────────┘  └──────────────┘  └─────────┘  │  │
│  └───────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────┘

AOSP 源码路径：

• frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
• frameworks/base/services/core/java/com/android/server/am/ActivityTaskManagerService.java
• frameworks/base/core/java/android/app/ActivityManager.java

1.2 AMS 的 Binder 继承链

AMS 的类继承关系体现了其作为 Binder 服务端的设计：

// frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public class ActivityManagerService extends IActivityManager.Stub
        implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {

// IActivityManager.Stub 由 AIDL 自动生成：
// frameworks/base/core/java/android/app/IActivityManager.aidl
// 编译后生成: IActivityManager.Stub extends Binder implements IActivityManager

这个继承链确保了 AMS 可以跨进程接收来自各应用进程的 Binder 调用。

二、AMS 的启动流程：从 SystemServer 到服务就绪

2.1 SystemServer 的 main 入口

一切从 SystemServer 开始。SystemServer 由 Zygote 进程 fork 出来，是 system_server 进程的 Java 入口。

// frameworks/base/services/java/com/android/server/SystemServer.java
public static void main(String[] args) {
    new SystemServer().run();
}

private void run() {
    // 设置主线程 Looper
    Looper.prepareMainLooper();
    // 加载 native 库
    System.loadLibrary("android_servers");
    // 创建系统上下文
    createSystemContext();
    // 创建 SystemServiceManager
    mSystemServiceManager = new SystemServiceManager(mSystemContext);

    // 启动三种类型的服务
    startBootstrapServices();   // 引导服务（AMS、PMS、PKMS 等）
    startCoreServices();        // 核心服务（BatteryService 等）
    startOtherServices();       // 其他服务（WMS、IMS 等）

    // 进入主线程消息循环
    Looper.loop();
}

2.2 startBootstrapServices 中启动 AMS

AMS 是第一个被启动的引导服务，因为所有其他服务的管理都依赖 AMS。其启动通过 SystemServiceManager 的反射机制创建 Lifecycle 内部类：

// frameworks/base/services/java/com/android/server/SystemServer.java
private void startBootstrapServices() {
    // 通过 Lifecycle 类启动 AMS
    mActivityManagerService = mSystemServiceManager.startService(
            ActivityManagerService.Lifecycle.class).getService();
    mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
    mActivityManagerService.setInstaller(installer);

    // 初始化电源管理
    mActivityManagerService.initPowerManagement();

    // 设置系统进程信息——这一步非常关键
    mActivityManagerService.setSystemProcess();
}

2.3 SystemServiceManager.startService 的反射机制

// frameworks/base/services/core/java/com/android/server/SystemServiceManager.java
public <T extends SystemService> T startService(Class<T> serviceClass) {
    final String name = serviceClass.getName();
    // 通过反射获取构造函数
    Constructor<T> constructor = serviceClass.getConstructor(Context.class);
    final T service = constructor.newInstance(mContext);
    // 注册到内部列表
    mServices.add(service);
    // 调用 onStart 生命周期方法
    service.onStart();
    return service;
}

2.4 ActivityManagerService.Lifecycle 内部类

这是 Android 系统服务的一种设计模式：将服务的构造和启动分离。Lifecycle 继承 SystemService，使得 AMS 的生命周期管理统一在 SystemService 框架之下。

// frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public static final class Lifecycle extends SystemService {
    private final ActivityManagerService mService;

    public Lifecycle(Context context) {
        super(context);
        mService = new ActivityManagerService(context);  // 构造 AMS
    }

    @Override
    public void onStart() {
        mService.start();  // 启动 AMS
    }

    @Override
    public void onBootPhase(int phase) {
        mService.mBootPhase = phase;
        if (phase == PHASE_SYSTEM_SERVICES_READY) {
            mService.mBatteryStatsService.systemServicesReady();
            mService.mServices.systemServicesReady();
        }
    }

    public ActivityManagerService getService() {
        return mService;
    }
}

2.5 AMS 构造函数——初始化全貌

AMS 构造函数是整个服务初始化的核心，在这里创建了所有子管理模块。下面是核心初始化逻辑（精简了部分代码）：

// frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public ActivityManagerService(Context systemContext) {
    mContext = systemContext;
    mSystemThread = ActivityThread.currentActivityThread();

    // 1. 创建主线程 Handler
    mHandlerThread = new ServiceThread(TAG, THREAD_PRIORITY_FOREGROUND, false);
    mHandlerThread.start();
    mHandler = new MainHandler(mHandlerThread.getLooper());

    // 2. 初始化广播队列（前台广播队列超时10秒，后台60秒）
    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;

    // 3. 初始化四大组件管理器
    mServices = new ActiveServices(this);
    mProviderMap = new ProviderMap(this);

    // 4. 创建 ActivityStack 管理器（Android 9 及之前的核心）
    //    Android 10 之后很多职责迁移到了 ATMS
    mStackSupervisor = createStackSupervisor();

    // 5. 创建 ATMS（Android 10+）
    mActivityTaskManager = new ActivityTaskManagerService(this);

    // 6. Activity 启动控制器
    mActivityStartController = new ActivityStartController(this);

    // 7. 进程状态追踪服务
    mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));

    // 8. 注册到 Watchdog 监控
    Watchdog.getInstance().addMonitor(this);
    Watchdog.getInstance().addThread(mHandler);
}

2.6 setSystemProcess——注册服务到 ServiceManager

AMS 启动后，通过 setSystemProcess 将自身注册到 ServiceManager（即 Binder 大管家）：

public void setSystemProcess() {
    // 将 AMS 注册到 ServiceManager
    ServiceManager.addService(Context.ACTIVITY_SERVICE, this, true,
            DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PRIORITY_NORMAL | DUMP_FLAG_PROTO);
    // 同时注册性能相关服务
    ServiceManager.addService("meminfo", new MemBinder(this));
    ServiceManager.addService("gfxinfo", new GraphicsBinder(this));
    ServiceManager.addService("cpuinfo", new CpuBinder(this));
    ServiceManager.addService("permission", new PermissionController(this));

    // 为 system_server 自身创建 ProcessRecord
    ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
            "android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
    synchronized (this) {
        ProcessRecord app = newProcessRecordLocked(info, info.processName, false, 0);
        app.persistent = true;       // system_server 是持久进程
        app.pid = MY_PID;
        app.maxAdj = ProcessList.SYSTEM_ADJ;  // OOM 优先级为 SYSTEM（最低被杀概率）
        mPidsSelfLocked.put(app.pid, app);
        updateLruProcessLocked(app, false, null);
        updateOomAdjLocked();
    }
}

三、ATMS 拆分：Android 10 的架构重构

从 Android 10 开始，Google 将 AMS 中与 Activity 任务管理相关的职责拆分到了 ActivityTaskManagerService（ATMS）。这一重构主要体现在：

职责划分：

• AMS：进程管理、Service、BroadcastReceiver、ContentProvider、OOM 调整、ANR 检测。
• ATMS：Activity 启动、Task 和 Stack 管理、生命周期调度。

ATMS 的核心数据结构（保持兼容但重构了实现）：

AOSP 路径：frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java

AMS (ActivityManagerService)
├── ATMS (ActivityTaskManagerService)  -- Android 10+ 新增
│   ├── RootWindowContainer    -- Window 容器根节点
│   │   ├── DisplayContent     -- 每个显示屏幕
│   │   │   └── TaskDisplayArea -- 任务显示区域
│   │   │       └── Task       -- 任务（原名 ActivityStack）
│   │   │           └── ActivityRecord -- Activity 记录
│   ├── ActivityStarter       -- Activity 启动控制器
│   └── ActivityTaskSupervisor -- Activity Task 监管器
├── ActiveServices            -- Service 管理
├── BroadcastQueue            -- 广播队列（前台+后台）
├── ProviderMap               -- ContentProvider 管理
└── OomAdjuster               -- OOM 调整器（Android 11+）

在 Android 9 及之前版本中，ActivityStack 和 ActivityStackSupervisor 位于 AMS 内部（com.android.server.am 包下）。从 Android 10 开始，这些类迁移到 com.android.server.wm 包下，职责也更清晰。

四、startActivity 全链路追踪

4.1 三个阶段概述

startActivity 的执行过程分为三个主要阶段：

阶段一：Launcher/App 进程 → system_server（Binder IPC）

Activity.startActivity()
→ Activity.startActivityForResult()
→ Instrumentation.execStartActivity()
→ ActivityTaskManager.getService().startActivity()  // Binder IPC
→ ATMS.startActivity()

阶段二：system_server 内部处理（ATMS → ActivityStarter → RootWindowContainer）

ATMS.startActivity()
→ ActivityStarter.execute()
→ ActivityStarter.startActivityUnchecked()
→ ActivityStarter.startActivityInner()
→ RootWindowContainer.resumeFocusedStacksTopActivities()
→ ActivityStack.startPausingLocked()   // 暂停当前 Activity
→ ActivityStackSupervisor.startSpecificActivityLocked()

阶段三：system_server → App 进程（Binder IPC → 生命周期回调）

ATMS.realStartActivityLocked()  // Binder 调用
→ ApplicationThread.scheduleTransaction()  // Binder IPC
→ ActivityThread.handleLaunchActivity()
→ Activity.onCreate()
→ Activity.onStart()
→ Activity.onResume()

4.2 关键代码：Instrumentation.execStartActivity

Instrumentation 是 Android 测试框架的基础，同时也是系统与 Activity 之间的监控层：

// frameworks/base/core/java/android/app/Instrumentation.java
public ActivityResult execStartActivity(
        Context who, IBinder contextThread, IBinder token, Activity target,
        Intent intent, int requestCode, Bundle options) {
    // ...
    int result = ActivityTaskManager.getService()
        .startActivity(whoThread, who.getBasePackageName(), intent,
                intent.resolveTypeIfNeeded(who.getContentResolver()),
                token, target != null ? target.mEmbeddedID : null,
                requestCode, 0, null, options);
    // 检查启动结果
    checkStartActivityResult(result, intent);
    return null;
}

这里 ActivityTaskManager.getService() 返回的是 ATMS 的 Binder 代理：

// frameworks/base/core/java/android/app/ActivityTaskManager.java
public static IActivityTaskManager getService() {
    return IActivityTaskManagerSingleton.get();
}

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);
        }
    };

4.3 ActivityStarter——启动决策核心

ActivityStarter 是 “解释如何以及然后启动一个 Activity 的控制器”。它收集所有关于如何将 Intent 和 flags 转化为 Activity 及其关联 Task 和 Stack 的逻辑。

// frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
/**
 * Controller for interpreting how and then launching an activity.
 *
 * This class collects all the logic for determining how an intent and flags
 * should be turned into an activity and associated task and stack.
 */
class ActivityStarter {
    private final ActivityTaskManagerService mService;
    private final ActivityTaskSupervisor mSupervisor;

    int execute() {
        try {
            if (mRequest.activityInfo == null) {
                // 通过 PackageManager 解析 Intent
                mRequest.resolveActivity(mSupervisor);
            }
            // 核心执行方法
            res = executeRequest(mRequest);
        } finally {
            // ...
        }
        return res;
    }

    private int startActivityUnchecked(final ActivityRecord r,
            ActivityRecord sourceRecord, IVoiceInteractionSession voiceSession,
            IVoiceInteractor voiceInteractor, int startFlags, boolean doResume,
            ActivityOptions options, Task inTask, ActivityRecord[] outActivity,
            boolean restrictedBgActivity) {

        // 根据 launchMode 和 Intent flags 决定 Activity 放入哪个 Task
        // launchMode: standard / singleTop / singleTask / singleInstance
        // Intent flags: FLAG_ACTIVITY_NEW_TASK / FLAG_ACTIVITY_CLEAR_TOP 等

        int result = START_SUCCESS;
        if (mStartActivity.resultTo == null && mLaunchSingleTop) {
            // singleTop: 如果栈顶已存在，则不创建新实例
            final Task task = mStartActivity.getTask();
            final ActivityRecord top = task.getTopActivity();
            if (top != null && !top.finishing && top.realActivity.equals(mStartActivity.realActivity)) {
                // 调用 onNewIntent 而非创建新实例
                top.deliverNewIntentLocked(...);
            }
        }
        // ... 更多 launchMode 处理
        mTargetStack.startActivityLocked(mStartActivity, topFocused, newTask, mKeepCurTransition, mOptions);
        return result;
    }
}

4.4 ActivityRecord 和 Task 的数据结构

// frameworks/base/services/core/java/com/android/server/wm/ActivityRecord.java
final class ActivityRecord extends WindowToken {
    final ActivityManagerService mService;  // AMS 引用
    final IApplicationToken.Stub appToken;  // WMS 的窗口令牌
    final ActivityInfo info;                // AndroidManifest 中解析的 ActivityInfo
    private Task task;                      // 所属 Task
    // 生命周期状态
    enum State { INITIALIZING, STARTED, RESUMED, PAUSING, PAUSED, STOPPING, STOPPED,
                 FINISHING, DESTROYING, DESTROYED, RESTARTING_PROCESS }
    private State state;
    ProcessRecord app;                      // 运行的进程
}

// frameworks/base/services/core/java/com/android/server/wm/Task.java
class Task extends WindowContainer<WindowContainer> {
    final int mTaskId;
    // 内部维护 ActivityRecord 列表
    void addActivityToTop(ActivityRecord r) {
        addChild(r, POSITION_TOP);
    }
}

五、进程管理与 ProcessRecord

5.1 ProcessRecord 数据结构

ProcessRecord 是 AMS 描述每个进程的完整数据结构。以下是 AOSP 中的关键字段分类：

身份标识：

• ApplicationInfo info — Manifest 中定义的 Application 信息
• int uid — 进程 UID
• int pid — 进程 PID
• String processName — 进程名（默认等于包名）
• IApplicationThread thread — ApplicationThread 的 Binder 代理，AMS 通过它向 App 进程发消息

组件记录（进程内运行的四大组件）：

• ArrayList<ActivityRecord> activities — 进程中所有 Activity
• ArraySet<ServiceRecord> services — 进程中所有 Service
• ArraySet<ReceiverList> receivers — 进程中所有 BroadcastReceiver
• ContentProviderRecord[] pubProviders — 已发布的 ContentProvider
• ArrayList<ContentProviderConnection> conProviders — 正在使用的 ContentProvider 连接

OOM 相关（进程调度核心）：

• int curAdj — 当前 OOM 调整值
• int setAdj — 已设置的 OOM 调整值
• int curProcState — 当前进程状态
• int maxAdj — 最大 OOM 调整值
• int adjSeq — OOM 调整周期序列号
• int lruSeq — LRU 更新周期序列号

进程状态标志：

• boolean persistent — 是否常驻内存
• boolean crashing — 是否正在 crash
• boolean notResponding — 是否处于 ANR 状态
• boolean killedByAm — 是否被 AMS 所杀
• boolean empty — 是否为空进程（无任何组件）

5.2 ProcessRecord 容器体系

AMS 维护多种容器来管理所有进程记录：

// 永久性容器
final ProcessMap<ProcessRecord> mProcessNames;  // 按进程名索引
final SparseArray<ProcessRecord> mPidsSelfLocked; // 按 PID 索引
final ArrayList<ProcessRecord> mLruProcesses;  // LRU 排序列表（决定 kill 顺序）

// 临时性容器
final ArrayList<ProcessRecord> mPersistentStartingProcesses; // 启动中的持久进程
final ArrayList<ProcessRecord> mProcessesOnHold;  // 挂起的进程
final ArrayList<ProcessRecord> mProcessesToGc;    // 待 GC 的进程

LRU 列表极为重要——越靠后的进程在内存不足时越优先被 kill。AMS 通过 updateLruProcessLocked 方法维护这个顺序。

六、ANR 检测机制详析

AMS 负责对 Android 系统的三类 ANR 进行检测和处理。

6.1 Service 超时检测（前台20秒，后台200秒）

// frameworks/base/services/core/java/com/android/server/am/ActiveServices.java
// 前台服务超时时间
static final int SERVICE_TIMEOUT = 20 * 1000;      // 20秒
// 后台服务超时时间
static final int SERVICE_BACKGROUND_TIMEOUT = SERVICE_TIMEOUT * 10;  // 200秒

void serviceTimeout(ProcessRecord proc) {
    if (proc.executingServices.size() > 0) {
        // 服务在规定时间内没有完成 onCreate/onStartCommand/onBind
        // 触发 ANR
        mAm.mAppErrors.appNotResponding(proc, null, null, false,
                "service timeout - " + proc.executingServices);
    }
}

6.2 BroadcastReceiver 超时检测

// frameworks/base/services/core/java/com/android/server/am/BroadcastQueue.java
// 前台广播超时
static final int BROADCAST_FG_TIMEOUT = 10 * 1000;   // 10秒
// 后台广播超时
static final int BROADCAST_BG_TIMEOUT = 60 * 1000;   // 60秒

final void processNextBroadcast(boolean fromMsg) {
    // 广播处理逻辑
    // 如果超时，触发 ANR
}

6.3 Input 事件分发超时（5秒）

InputDispatcher 层面的超时由 InputManagerService 管理。当应用主线程在 5 秒内未响应输入事件时触发。AOSP 路径：

• frameworks/native/services/inputflinger/dispatcher/InputDispatcher.cpp

6.4 ANR 处理流程

// frameworks/base/services/core/java/com/android/server/am/AppErrors.java
void appNotResponding(ProcessRecord proc, ActivityRecord activity,
        ActivityRecord parent, boolean aboveSystem, final String annotation) {
    // 1. 收集 ANR trace（dump 所有线程堆栈）
    File tracesFile = ActivityManagerService.dumpStackTraces(
            true, firstPids, lastPids, nativePids, null);

    // 2. 显示 ANR 对话框或直接杀进程
    if (showBackground) {
        // 显示 ANR 对话框
        makeAppNotRespondingDialog(proc, activity);
    } else {
        // 后台 ANR 直接杀进程
        mService.killAppAtUsersRequest(proc, null);
    }
}

七、OOM 调整与 Low Memory Killer 集成

AMS 通过 updateOomAdjLocked 方法持续计算每个进程的 oom_score_adj 值。这些值被写入 /proc/<pid>/oom_score_adj，供内核的 LMK 或用户空间的 lmkd 守候进程使用。

// frameworks/base/services/core/java/com/android/server/am/OomAdjuster.java (Android 11+)
// 或者在 Android 10 及之前版本中，在 AMS.java 中
void updateOomAdjLocked() {
    // 遍历所有进程，根据以下因素计算 oom_adj:
    // - 进程是否在前台 (FOREGROUND_APP_ADJ = 0)
    // - 是否有可见 Activity (VISIBLE_APP_ADJ = 100)
    // - 是否有前台 Service (PERCEPTIBLE_APP_ADJ = 200)
    // - 是否正在备份 (BACKUP_APP_ADJ = 300)
    // - 是否有后台 Service (SERVICE_B_ADJ = 800)
    // - 是否为缓存进程 (CACHED_APP_MIN_ADJ = 900)

    // 将计算出的 adj 写入 /proc/<pid>/oom_score_adj
    applyOomAdjLocked(proc, true, now, nowElapsed);
}

OOM ADJ 值体系（frameworks/base/services/core/java/com/android/server/am/ProcessList.java）：

• FOREGROUND_APP_ADJ = 0 — 前台应用
• VISIBLE_APP_ADJ = 100 — 可见应用（如被对话框遮盖）
• PERCEPTIBLE_APP_ADJ = 200 — 可感知应用（前台 Service）
• BACKUP_APP_ADJ = 300 — 备份应用
• HEAVY_WEIGHT_APP_ADJ = 400 — 重量级应用
• SERVICE_ADJ = 500 — 有 Service 的进程
• HOME_APP_ADJ = 600 — Launcher 应用
• PREVIOUS_APP_ADJ = 700 — 上一个使用的应用
• SERVICE_B_ADJ = 800 — 有后台 Service 的进程
• CACHED_APP_MIN_ADJ = 900 — 缓存进程（最先被 kill）
• CACHED_APP_MAX_ADJ = 906 — 最弱的缓存进程
• UNKNOWN_ADJ = 1001 — 未知
• SYSTEM_ADJ = -900 — 系统进程（永不 kill）

八、关键面试题

Q1：Android 10 为什么要从 AMS 拆分出 ATMS？拆分后两者的职责边界是什么？

AMS 代码量在 Android 9 时已超过 2 万行，维护极其困难。拆分后 ATMS 专门负责 Activity Task 管理（启动、Task 组织、生命周期），AMS 保留进程管理、Service/BroadcastReceiver/ContentProvider 管理、ANR/OOM 等职责。这种拆分符合单一职责原则，也使得窗口管理（WMS）与 Activity 管理（ATMS）的交互更自然（两者都在 com.android.server.wm 包下）。

Q2：startActivity 过程中，ApplicationThread 的 scheduleTransaction 是如何将任务调度到主线程的？

ApplicationThread 是 ActivityThread 的内部类，继承自 IApplicationThread.Stub。当 system_server 通过 Binder 调用 scheduleTransaction 时，Binder 线程执行该方法，它通过 Handler 向主线程发送消息（mH.sendMessage），从而将 ClientTransaction（封装了多种生命周期回调）调度到主线程的 MessageQueue 中，由主线程的 Looper 依次处理。

Q3：ANR 的检测原理是什么？谁在监测超时？

AMS 使用延迟消息机制检测 ANR。当调用目标进程执行某个操作时，AMS 的 Handler 会向自己的消息队列 post 一条延迟消息（Service 超时 20 秒、广播超时 10/60 秒）。如果目标进程在规定时间内完成操作并通知 AMS 移除这条延迟消息，则一切正常。如果延迟消息到期被处理，则说明超时，AMS 将触发 ANR 流程（收集 trace、显示对话框或杀进程）。

AOSP 核心路径参考：

• frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
• frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
• frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
• frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java
• frameworks/base/services/core/java/com/android/server/am/ProcessRecord.java
• frameworks/base/services/core/java/com/android/server/am/BroadcastQueue.java
• frameworks/base/services/core/java/com/android/server/am/ActiveServices.java
• frameworks/base/services/core/java/com/android/server/am/OomAdjuster.java
• frameworks/base/core/java/android/app/ActivityTaskManager.java
• frameworks/base/core/java/android/app/Instrumentation.java