#Janus# 安卓系统启动流程之《AMS 启动流程》_ams流程梳理

最近学习系统启动流程，这里对于AMS是如何启动的过程做一个输出，基于安卓源码8.0版本。

AMS的介绍就不多说了，百度一大堆，下面直接上过程：

SystemServer.class 中main方法里，调用了SystemServer的run()方法

/**

* The main entry point from zygote.

*/

public static void main(String[] args) {

    new SystemServer().run();

}

1
2
3
4
5
6
7
8
9
10
11
12

看一下run()方法里做了什么：

private void run() {

    try {
        traceBeginAndSlog("InitBeforeStartServices");
        if (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) {
            Slog.w(TAG, "System clock is before 1970; setting to 1970.");
            SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME);
        }
        String timezoneProperty =  SystemProperties.get("persist.sys.timezone");
        if (timezoneProperty == null || timezoneProperty.isEmpty()) {
            Slog.w(TAG, "Timezone not set; setting to GMT.");
            SystemProperties.set("persist.sys.timezone", "GMT");

        }

        if (!SystemProperties.get("persist.sys.language").isEmpty()) {
            final String languageTag = Locale.getDefault().toLanguageTag();
            SystemProperties.set("persist.sys.locale", languageTag);
            SystemProperties.set("persist.sys.language", "");
            SystemProperties.set("persist.sys.country", "");
            SystemProperties.set("persist.sys.localevar", "");
        }

        Binder.setWarnOnBlocking(true);

        Slog.i(TAG, "Entered the Android system server!");

        int uptimeMillis = (int) SystemClock.elapsedRealtime();

        EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_SYSTEM_RUN, uptimeMillis);

        if (!mRuntimeRestart) {

            MetricsLogger.histogram(null, "boot_system_server_init", uptimeMillis);

        }

        SystemProperties.set("persist.sys.dalvik.vm.lib.2", VMRuntime.getRuntime().vmLibrary());

        VMRuntime.getRuntime().clearGrowthLimit();

        VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);

        Build.ensureFingerprintProperty();

        Environment.setUserRequired(true);

        BaseBundle.setShouldDefuse(true);

        BinderInternal.disableBackgroundScheduling(true);

        BinderInternal.setMaxThreads(sMaxBinderThreads);

        android.os.Process.setThreadPriority(

            android.os.Process.THREAD_PRIORITY_FOREGROUND);

        android.os.Process.setCanSelfBackground(false);

        Looper.prepareMainLooper();

        System.loadLibrary("android_servers");

        performPendingShutdown();

        createSystemContext();

        mSystemServiceManager = new SystemServiceManager(mSystemContext);

        mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);

        LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);

        SystemServerInitThreadPool.get();

    } finally {

        traceEnd();  // InitBeforeStartServices

    }
    // ① 重点在这里，这里启动了各种系统服务，我们关注的AMS，也是由 startBootstrapServices(); 方法启动的。
    try {
         traceBeginAndSlog("StartServices");
         startBootstrapServices();
         startCoreServices();
         startOtherServices();
         SystemServerInitThreadPool.shutdown();

    } catch (Throwable ex) {

        Slog.e("System", "******************************************");

        Slog.e("System", "************ Failure starting system services", ex);

        throw ex;

    } finally {

        traceEnd();

    }

    if (StrictMode.conditionallyEnableDebugLogging()) {
        Slog.i(TAG, "Enabled StrictMode for system server main thread.");
    }

    if (!mRuntimeRestart && !isFirstBootOrUpgrade()) {
        int uptimeMillis = (int) SystemClock.elapsedRealtime();
        MetricsLogger.histogram(null, "boot_system_server_ready", uptimeMillis);
        final int MAX_UPTIME_MILLIS = 60 * 1000;
        if (uptimeMillis > MAX_UPTIME_MILLIS) {
            Slog.wtf(SYSTEM_SERVER_TIMING_TAG,
                    "SystemServer init took too long. uptimeMillis=" + uptimeMillis);
        }
    }
    // Loop forever.
    Looper.loop();
    throw new RuntimeException("Main thread loop unexpectedly exited");

}

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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

在注释①的位置，就是启动各种服务方法，在startBootstrapServices()中启动了ActivityManagerService，继续往下看：

private void startBootstrapServices() {

   …//多余代码删除

    // Activity manager runs the show.

    traceBeginAndSlog("StartActivityManager");

    mActivityManagerService = mSystemServiceManager.startService(ActivityManagerService.Lifecycle.class).getService();

    mActivityManagerService.setSystemServiceManager(mSystemServiceManager);

    mActivityManagerService.setInstaller(installer);

    traceEnd();

…//多余代码删除

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

首先先看这一行代码

mActivityManagerService = mSystemServiceManager.startService(ActivityManagerService.Lifecycle.class).getService();
1

这里调用了mSystemServiceManager.startService()方法，并且传入了一个ActivityManagerService.Lifecycle.class作为参数，然后再调用getService()方法获取到AMS对象；

这里有三个问题：

第一、ActivityManagerService.Lifecycle.class是什么？

第二、mSystemServiceManager是谁？

第三、 mSystemServiceManager.startService里做了什么？

首先第一个问题，ActivityManagerService.Lifecycle.class是什么呢？我们先点进去看他的代码：

public class ActivityManagerService extends IActivityManager.Stub

    implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {

…//省略多余代码

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

        }
        public ActivityManagerService getService() {

            return mService;

        }

    }

…//省略多余代码

}

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

从代码中来看，他是ActivityManagerService内部的一个静态内部类，继承了SystemService，在其内部构造方法中初始化了ActivityManagerService的实例，而且onStart()方法中调用了AMS的start()方法，getService()方法返回了AMS的实例。

那么我们大胆推测，这个Lifecycle，就是用来获取AMS实例对象并且启动AMS的包装类！现在我们知道谁来启动AMS了，那么启动方法是在哪里调用的呢？

带着疑问我们先继续看第二个问题，mSystemServiceManager又是什么呢？继续看代码

/**
* All system services
*/
SystemServiceManager mSystemServiceManager;
1
2
3
4

mSystemServiceManager是SystemServiceManager，他主要的作用就是管理SystemService系统服务的创建、启动和其他生命周期事件。

继续第三个问题，startService()方法中做了什么：

我们进入它的startService()方法中看一下，同名方法有很多，我们上面的代码中参数传入的是一个class，并且我们已经知道ActivityManagerService.Lifecycle继承了SystemService，所以我们应该查看这个带泛型并且参数为class的方法