ActivityManagerService（俗称AMS）是一个非常重要的系统服务，它是在SystemServer中被启动的进程之一。作用及其广泛，主管的就是应用App的四大组件以及进程信息，可以说它管理着app世界的所有应用。zygote孵化所有java进程，system_server管理所有服务，AMS管理所有app进程。

源码基于Android 13

ActivityManagerService

AMS作为一个系统服务，也是在SystemServer中启动的，并且属于是bootstrap类型的服务，会被添加到WatchDog的监控中。通常情况下，这些服务都是由SystemServiceManager通过反射启动的，这里也不例外。这里我们可以看下其启动流程：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
// frameworks/base/services/java/com/android/server/SystemServer.java

public final class SystemServer implements Dumpable {
    private void startBootstrapServices(@NonNull TimingsTraceAndSlog t) {
        ...
        // ATMS启动
        ActivityTaskManagerService atm = mSystemServiceManager.startService(
                ActivityTaskManagerService.Lifecycle.class).getService();
        // AMS启动
        mActivityManagerService = ActivityManagerService.Lifecycle.startService(
                mSystemServiceManager, atm);
        mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
        mActivityManagerService.setInstaller(installer);
        ...
        // 设置SystemServer进程
        mActivityManagerService.setSystemProcess();
    }
    
    private void startOtherServices(@NonNull TimingsTraceAndSlog t) {
        // 安装provider
        mActivityManagerService.getContentProviderHelper().installSystemProviders();
        ...
        // 设置WMS
        mActivityManagerService.setWindowManager(wm);
        ...
        // AMS完成之后的回调
        mActivityManagerService.systemReady(() -> {
            // 观测natice的崩溃
            try {
                mActivityManagerService.startObservingNativeCrashes();
            } catch (Throwable e) {
                reportWtf("observing native crashes", e);
            }
            ...
        }
    }
}

这里可以看到在启动AMS前还先启动了ATMS，然后作为参数传递给AMS进行启动。这里ATMS也是一个服务，它是由AMS拆分出来的专门管理Activity的一个服务，后面我们再单独查看，这里看下AMS的启动并不是直接启动的，而是经由了其Lifecycle间接启动。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

public class ActivityManagerService extends IActivityManager.Stub
        implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback, ActivityManagerGlobalLock {
    public static final class Lifecycle extends SystemService {
        private final ActivityManagerService mService;
        private static ActivityTaskManagerService sAtm;

        public Lifecycle(Context context) {
            super(context);
            // 2. 由SystemServiceManager反射走到构造方法中
            mService = new ActivityManagerService(context, sAtm);
        }

        // 1.从SystemServer中调用该方法进行启动
        public static ActivityManagerService startService(
                SystemServiceManager ssm, ActivityTaskManagerService atm) {
            sAtm = atm;
            return ssm.startService(ActivityManagerService.Lifecycle.class).getService();
        }

        @Override
        public void onStart() {
            // 3. 构造出对象后调用其onStart
            mService.start();
        }
        ...
    }
    ...
}

AMS并不是直接被启动的，而是由其静态内部类Lifecycle创建并启动的。我们在前面知道，所有通过SystemServiceManager启动的服务都是会被添加到其内部的集合中的，因此这里添加到服务集合中的实际上是AMS.Lifecycle对象，只不过我们可以通过它间接获取到AMS而已。 接下来我们看其构造方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
// frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

public class ActivityManagerService extends IActivityManager.Stub
        implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback, ActivityManagerGlobalLock {

    public ActivityManagerService(Context systemContext, ActivityTaskManagerService atm) {
        // systemServer线程
        mSystemThread = ActivityThread.currentActivityThread();
        mUiContext = mSystemThread.getSystemUiContext();

        // HandlerThread线程
        mHandlerThread = new ServiceThread(TAG,
                THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
        mHandlerThread.start();
        mHandler = new MainHandler(mHandlerThread.getLooper());
        // UI线程的handler
        mUiHandler = mInjector.getUiHandler(this);
       
        // 进程管理
        mProcessList = mInjector.getProcessList(this);
        mProcessList.init(this, activeUids, mPlatformCompat);
        // 性能管理
        mAppProfiler = new AppProfiler(this, BackgroundThread.getHandler().getLooper(),
                new LowMemDetector(this));
        mPhantomProcessList = new PhantomProcessList(this);
        // oom_adj用于杀进程的
        mOomAdjuster = new OomAdjuster(this, mProcessList, activeUids);

        // 广播管理
        ...
        mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
                "foreground", foreConstants, false);
        mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
                "background", backConstants, true);
        mBgOffloadBroadcastQueue = new BroadcastQueue(this, mHandler,
                "offload_bg", offloadConstants, true);
        mFgOffloadBroadcastQueue = new BroadcastQueue(this, mHandler,
                "offload_fg", foreConstants, true);
        mBroadcastQueues[0] = mFgBroadcastQueue;
        mBroadcastQueues[1] = mBgBroadcastQueue;
        mBroadcastQueues[2] = mBgOffloadBroadcastQueue;
        mBroadcastQueues[3] = mFgOffloadBroadcastQueue;
        // Service管理
        mServices = new ActiveServices(this);
        // ContentProvider管理
        mCpHelper = new ContentProviderHelper(this, true);
        mPackageWatchdog = PackageWatchdog.getInstance(mUiContext);
        // app崩溃管理
        mAppErrors = new AppErrors(mUiContext, this, mPackageWatchdog);
        mUidObserverController = new UidObserverController(mUiHandler);

        ...
        // Acitivity管理
        mActivityTaskManager = atm;
        mActivityTaskManager.initialize(mIntentFirewall, mPendingIntentController,
                DisplayThread.get().getLooper());
        mAtmInternal = LocalServices.getService(ActivityTaskManagerInternal.class);

        // 加入看门狗监控中
        Watchdog.getInstance().addMonitor(this);
        Watchdog.getInstance().addThread(mHandler);
        ...
    }
}

构造方法中主要是初始化，这里获取了三个线程，分别是系统线程也就是SystemServer所在的线程，然后是前台线程，最后是UI线程。接下来就是它的一些管理器，管理各个功能，这里大体上看下构造方法，然后回到启动方法start中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

public class ActivityManagerService extends IActivityManager.Stub
        implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback, ActivityManagerGlobalLock {
    private void start() {
        // 发布电池状态服务
        mBatteryStatsService.publish();
        // 发布app信息服务
        mAppOpsService.publish();
        // 发布进程状态服务
        mProcessStats.publish();
        // 将ActivityManagerInternal注册到本地服务，抽象方法，实现在其内部类InternalService中
        LocalServices.addService(ActivityManagerInternal.class, mInternal);
        // 与LocalServices类一样
        LocalManagerRegistry.addManager(ActivityManagerLocal.class,
                (ActivityManagerLocal) mInternal);
        mActivityTaskManager.onActivityManagerInternalAdded();
        mPendingIntentController.onActivityManagerInternalAdded();
        mAppProfiler.onActivityManagerInternalAdded();
        CriticalEventLog.init();
    }
}

其实就是注册各种服务，注意在AMS中的很多服务都是Binder服务，因此需要注册到ServiceManager或者作为本地服务注册到LocalServices中。同样的，具体细节我们后面再看，到这里算是启动完成，然后我们再次回到SystemServer中，接下来是设置系统进程。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
// frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

public class ActivityManagerService extends IActivityManager.Stub
        implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback, ActivityManagerGlobalLock {
    public void setSystemProcess() {
        try {
            // 注册AMS，以及其他服务
            ServiceManager.addService(Context.ACTIVITY_SERVICE, this, /* allowIsolated= */ true,
                    DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PRIORITY_NORMAL | DUMP_FLAG_PROTO);
            ...

            // 获取应用信息，这里的包名固定为android，属于系统
            ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
                    "android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
            mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());

            synchronized (this) {
                // 构建一个进程记录，用于管理SystemServer进程
                ProcessRecord app = mProcessList.newProcessRecordLocked(info, info.processName,
                        false,
                        0,
                        false,
                        0,
                        null,
                        new HostingRecord(HostingRecord.HOSTING_TYPE_SYSTEM));
                app.setPersistent(true);
                app.setPid(MY_PID);
                app.mState.setMaxAdj(ProcessList.SYSTEM_ADJ);
                app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
                app.mProfile.addHostingComponentType(HOSTING_COMPONENT_TYPE_SYSTEM);
                addPidLocked(app);
                // 更新最近使用进程
                updateLruProcessLocked(app, false, null);
                // 设置oom_adj，内存不足时会根据该值杀进程
                updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
            }
        } catch (PackageManager.NameNotFoundException e) {
            throw new RuntimeException(
                    "Unable to find android system package", e);
        }
        ...
    }
}

可以看到，在这里SystemServer整个进程也是被当成了一个应用，其包名为android，然后交由AMS进行管理。继续往下看，就是发布系统的ContentProvider，这里就是从ProcessList中查询名为system的进程中的ContentProvider，然后进行注册。再次回到SystemServer中，在最后的其他进程也启动完毕后，会执行AMS的ready方法来表示其已完成启动。

到这里基本上AMS启动已经完成了，实际上来看AMS就是一个大管家类型的服务，虽然它管理很多的功能，但实际上这些功能都被拆分出一个一个的服务，由这些服务单独管理，然后AMS统筹处理。