Android ActivityManagerService(1)

发表于 | 分类于

在Android系统中，ActivityManagerService即AMS是管理Android四大组件的核心，其重要性不言而喻。那么，从本篇文章就开始分析AMS的源码，理解其内部的逻辑。

ActivityManagerService对象的创建

Android系统启动SystemServer这里已经讲了，ActivityManagerService最初的创建位置在SystemServer的startBootstrapServices方法内。

1
2
3
4
5
6
7
8
9
10
11
12
//frameworks/base/servces/java/com/android/server/SystemServer.java
private void startBootstrapServices() {
    Installer installer = mSystemServiceManager.startService(Installer.class);
    // Activity manager runs the show.
    mActivityManagerService = mSystemServiceManager.startService(
    ActivityManagerService.Lifecycle.class).getService();
    mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
    mActivityManagerService.setInstaller(installer);
    
    // 为系统进程创建并启动Application实例
    mActivityManagerService.setSystemProcess();
}

该方法表示通过SystemServiceManager的startService方法，启动Lifecycle后获取服务。然后为系统进程创建并启动Application实例。
　　Lifecycle是ActivityManagerService的内部静态类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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;
    }
}

可以看出Lifecycle类的作用，就是在ActivityManagerSerivce与SystemService之间充当适配器的作用。
　　再回头看一下SystemServiceManager的startService方法做了什么。

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
//frameworks/base/services/core/java/com/android/server/SystemServiceManager.java
public <T extends SystemService> T startService(Class<T> serviceClass) {
    try {
        final String name = serviceClass.getName();
        Slog.i(TAG, "Starting " + name);
        Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "StartService " + name);

        // Create the service.
        if (!SystemService.class.isAssignableFrom(serviceClass)) {
            throw new RuntimeException("Failed to create " + name
                    + ": service must extend " + SystemService.class.getName());
        }
        final T service;
        Constructor<T> constructor = serviceClass.getConstructor(Context.class);
        service = constructor.newInstance(mContext);
        // Register it.
        mServices.add(service);

        // Start it.
        service.onStart();
        return service;
    } finally {
        Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
    }
}

这里通过构造器创建一个SystemService的子类实例，这里即Lifecycle类的实例，再调用service.onStart()方法。
　　在Lifecycle的构造方法中，会根据传入的Context参数创建一个ActivityManagerService对象。那我们看一下ActivityManagerService的构造方法。

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
//frameworks/base/servces/core/java/com/android/server/am/ActivityManagerService.java

public ActivityManagerService(Context systemContext) {
    ...
    mInjector = new Injector();
    mContext = systemContext;

    mFactoryTest = FactoryTest.getMode();
    mSystemThread = ActivityThread.currentActivityThread();
    mUiContext = mSystemThread.getSystemUiContext();
    ...
    // 创建名为ActivityManagerService的前台线程
    mHandlerThread = new ServiceThread(TAG, THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
    mHandlerThread.start();
    mHandler = new MainHandler(mHandlerThread.getLooper());
    // 创建UI线程
    mUiHandler = mInjector.getUiHandler(this);
    ...
    // 创建前台广播队列和后台广播队列
    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;
    ...
    // 创建"/data/system"目录
    File dataDir = Environment.getDataDirectory();
    File systemDir = new File(dataDir, "system");
    systemDir.mkdirs();
    ...
    // 所有Activity的启动都要通过mStackSupervisor执行
    mStackSupervisor = new ActivityStackSupervisor(this);
    mActivityStarter = new ActivityStarter(this, mStackSupervisor);
    ...
    mProcessCpuThread = new Thread("CpuTracker") {
        @Override
        public void run() {
            synchronized (mProcessCpuTracker) {
                mProcessCpuInitLatch.countDown();
                mProcessCpuTracker.init();
            }
            ...
        }
    }
}

　　ActivityManagerService的构造方法创建了ActivityManagerService线程、UI线程和CpuTracker线程，同时创建了系统目录以及用于创建Activity的StackSupervisor和ActivityStarter。
　　到这里，ActivityManagerService对象就创建完毕。

ActivityManagerService对象创建后操作

下面我们再看一下startService(SystemService)方法。

1
2
3
4
5
6
7
8
9
10
11
// \frameworks\base\services\core\java\com\android\server\SystemServiceManager.java
public <T extends SystemService> T startService(Class<T> serviceClass) {
	...
    // Register it.
    mServices.add(service);

    // Start it.
    try {
    	service.onStart();
    } 
}

这个方法主要做了两件事情，一个是注册服务，另一个就是启动服务。而Lifecycle的onStart方法中又会调用ActivityManagerService的start方法，下面跟踪一下该方法。

1
2
3
4
5
6
7
8
9
private void start() {
    Process.removeAllProcessGroups();
    // 启动CpuTracker线程
    mProcessCpuThread.start();
    mBatteryStatsService.publish(mContext);
    mAppOpsService.publish(mContext);
    Slog.d("AppOps", "AppOpsService published");
    LocalServices.addService(ActivityManagerInternal.class, new LocalService());
}

到这里，ActivityManagerService就已经创建起来了。

我们再回到SystemServer的startBootstrapServices方法中，在创建了ActivityManagerService后，又调用了其setSystemProcess方法。

1
2
// 为系统进程创建并启动Application实例
mActivityManagerService.setSystemProcess();
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
public void setSystemProcess() {
    try {
        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));

        ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
                "android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
        mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());

        synchronized (this) {
            ProcessRecord app = newProcessRecordLocked(info, info.processName, false, 0);
            app.persistent = true;
            app.pid = MY_PID;
            app.maxAdj = ProcessList.SYSTEM_ADJ;
            app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
            synchronized (mPidsSelfLocked) {
                mPidsSelfLocked.put(app.pid, app);
            }
            updateLruProcessLocked(app, false, null);
            updateOomAdjLocked();
        }
    }
}

该方法的主要作用是为系统进程创建并启动Application实例并启动，同时也注册一些服务。
　　现在我们再回头看一下SystemServer调用startBootstrapServices方法的地方。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//frameworks/base/servces/java/com/android/server/SystemServer.java

// zygote的主进入点
public static void main(String[] args) {
    new SystemServer().run();
}

private void run() {
    ...
    try {
        traceBeginAndSlog("StartServices");
        startBootstrapServices();
        startCoreServices();
        startOtherServices();
        SystemServerInitThreadPool.shutdown();
    }
    ...
}

在执行了startBootstrapServices方法后，又接着调用了startCoreServices方法和startOtherServices方法。这两个方法用于启动一些在startBootstrapServices方法内没有启动的必要服务和其他各种服务。

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/servces/java/com/android/server/SystemServer.java

private void startCoreServices() {
    ...
    // 检测应用统计    mActivityManagerService.setUsageStatsManager(LocalServices.getService(UsageStatsManagerInternal.class));
    ...
}

private void startOtherServices() {
    ...
    mActivityManagerService.installSystemProviders();
    ...
    final Watchdog watchdog = Watchdog.getInstance();
    watchdog.init(context, mActivityManagerService);
    ...
    // 通知ActivityManagerService
    mActivityManagerService.systemReady(() -> {
        ...
        mSystemServiceManager.startBootPhase(SystemService.PHASE_ACTIVITY_MANAGER_READY);
        ...
        try {
            mActivityManagerService.startObservingNativeCrashes();
        }
        ...
        try {
            startSystemUi(context, windowManagerF);
        }
        ...
        // 通知若干系统服务systemReady
        ...
        // 启动Watchdog
        Watchdog.getInstance().start();
        ...
        // 通知若干系统服务systemRunning
        ...
    }, BOOT_TIMINGS_TRACE_LOG);
}

这里调用了ActivityManagerService的systemReady方法，其中的Lambda表达式应为Runnable类型。

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
//frameworks/base/servces/core/java/com/android/server/am/ActivityManagerService.java

public void systemReady(final Runnable goingCallback, TimingsTraceLog traceLog) {
    synchronized(this) {
        if (mSystemReady) {
            if (goingCallback != null) {
                // 执行回调
                goingCallback.run();
            }
            return;
        }
        mLocalDeviceIdleController = LocalServices.getService(DeviceIdleController.LocalService.class);
        mAssistUtils = new AssistUtils(mContext);
        mVrController.onSystemReady();
        mUserController.onSystemReady();
        mRecentTasks.onSystemReadyLocked();
        mAppOpsService.systemReady();
        mSystemReady = true;
    }
    ...
    // 检查需要kill的进程，并执行kill，且不允许重启
    ArrayList<ProcessRecord> procsToKill = null;
    synchronized(mPidsSelfLocked) {
        for (int i=mPidsSelfLocked.size()-1; i>=0; i--) {
            ProcessRecord proc = mPidsSelfLocked.valueAt(i);
            if (!isAllowedWhileBooting(proc.info)){
                if (procsToKill == null) {
                    procsToKill = new ArrayList<ProcessRecord>();
                }
                procsToKill.add(proc);
            }
        }
    }
    synchronized(this) {
        if (procsToKill != null) {
            for (int i=procsToKill.size()-1; i>=0; i--) {
                ProcessRecord proc = procsToKill.get(i);
                removeProcessLocked(proc, true, false, "system update done");
            }
        }
        mProcessesReady = true;
    }
    ...
    retrieveSettings();
    ...
    // 执行回调
    if (goingCallback != null) goingCallback.run();
    ...
    synchronized (this) {
        // 启动持久化进程
        startPersistentApps(PackageManager.MATCH_DIRECT_BOOT_AWARE);
        ...
        // 启动桌面Activity
        startHomeActivityLocked(currentUserId, "systemReady");
        ...
        try {
            // 发送ACTION_USER_STARTED广播
            Intent intent = new Intent(Intent.ACTION_USER_STARTED);
            intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY | Intent.FLAG_RECEIVER_FOREGROUND);
            intent.putExtra(Intent.EXTRA_USER_HANDLE, currentUserId);
            broadcastIntentLocked(null, null, intent, null, null, 0, null, null, null, AppOpsManager.OP_NONE, null, false, false, MY_PID, SYSTEM_UID, currentUserId);
            // 发送ACTION_USER_STARTING广播
            intent = new Intent(Intent.ACTION_USER_STARTING);
            intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
            intent.putExtra(Intent.EXTRA_USER_HANDLE, currentUserId);
            broadcastIntentLocked(null, null, intent, null, 
                new IIntentReceiver.Stub() {
                    @Override
                    public void performReceive(Intent intent, int resultCode, String data, Bundle extras, boolean ordered, boolean sticky, int sendingUser) throws RemoteException {
                    }
                }, 
                0, null, null, new String[] {INTERACT_ACROSS_USERS}, AppOpsManager.OP_NONE, null, true, false, MY_PID, SYSTEM_UID, UserHandle.USER_ALL);
        }
        ...
        mStackSupervisor.resumeFocusedStackTopActivityLocked();
        ...
    }
}

该方法可以根据goingCallback.run()的执行时间，分为三个部分。

  1. 在goingCallback.run()执行之前的主要操作是通知systemReady和杀掉启动时不被允许的进程。
  2. goingCallback.run()方法主要用于启动各种系统服务进程
  3. 在goingCallback.run()执行之后的主要操作是启动持久化进程、启动桌面Activity、发布ACTION_USER_STARTED和ACTION_USER_STARTING广播。
总结

　　本篇文章主要分析ActivityManagerService的创建和启动逻辑。在后续文章中，会对ActivityManangerService的具体使用，对四大组件进行管理，以及内存管理等内容进行分析。