ActivityManagerService的内部原理——概要

发表于

ActivityManagerService简介

  • ActivityManagerService（AMS）是android系统中一个非常重要的服务，主要用来管理四大组件Activity、ContentProvider、Service、Broadcast和内存进程调度。它就像一个大管家，管理着android系统中非常重要的组件，但它又不管理android中所有的重要对象，比如窗口相关的组件由WindowManagerService服务来管理，与通知相关的组件由NotificationManagerService服务来管理。

  • AMS的代码量巨大，总计20000+，这些代码只是其中一个类，它的实现还需要很多辅助类来共同完成。AMS是android三大核心功能之一，另外两个是WindowManagerService和View。尽管AMS的代码庞大，逻辑纷繁，但从所提供的功能来看，却没有看上去那么复杂。AMS所提供的主要功能包括以下几项：

    • 统一调度各应用程序的Activity。应用程序要运行Activity，会首先报告给AMS，然后由AMS决定该Activity是否可以启动，如果可以，AMS再通知应用程序运行指定的Activity。换句话说，运行Activity是各应用程序的“内政”，AMS并不干预，但是AMS必须知道各应用程序都运行了哪些Activity。
    • 内存管理。android官方声称，Activity退出后，其所在的进程并不会被立刻杀死，从而下次再启动该Activity时就能够提高启动速度。这些Activity只有当系统内存紧张时，才会被自动杀死，应用程序不用关心这个问题。而这些正是在AMS中完成的。
    • 进程管理。AMS向外提供了查询系统正在运行的进程信息的API。

    AMS提供的主要功能

几个重要概念

AMS中定义了几个重要的数据类，分别用来保存进程（Process）、活动（Activity）、服务（Service）、广播（Broadcast）和任务（Task）等。

  • 进程数据类ProcessRecord

    表示一个进程信息，包括该进程里的Activity和Service等信息。

  • ActivityRecord数据类

    表示单个Activity，它是堆栈中的基本单元。

  • ActivityRecord::Token

    表示ActivityRecord中的内部静态类，继承与IApplicationToken.Stub，是一个Binder对象。它有两个作用：一是作为远程对象的本地句柄，用于进程间通信，二是作为关系映射中的unique ID。这个Token最后传递给应用程序客户端ActivityThread和服务WMS中。

    AMS、WMS、APP中的Token关系

    AMS中的appToken在ActivityRecord的构造方法中被创建，创建好之后，它首先传递到WMS中构造一个AppWindowToken对象，这个传递过程由AMS通过调用WMS的addAppToken()方法来完成。接着appToken对象会传递到应用程序客户端ActivityThread中去构造ActivityClientRecord对象，而这个传递过程是AMS通过调用应用程序客户端ActivityThread的scheduleLauncherActivity()方法来完成的。最后，应用程序客户端还会通过调用addToDisplay()方法把这个对象传递到WMS中去，目的是去找到AMS传递到WMS时生成的APPWindowToken对象，验证当前窗口和Activity创建时的窗口是否一一对应。若ActivityRecord、ActivityClientRecord和APPWindowToken一一对应，则ActivityRecord代表Activity，APPWindowToken代表当前窗口，并且ActivityRecord和APPWindowToken有相同的Z轴位置，同时它们的Z轴还必须相同。如果Z轴不相同，界面的显示就会不一致。在android系统中，AMS和WMS都维护一个共同的Z轴位置，Z轴位置越大表示界面越显示在上面。

  • ServiceRecord数据类

    表示单个Service，对应客户端的一个Service。

  • BroadcastRecord数据类

    表示单个Broadcast，对应客户端一个Broadcast。

  • TaskRecord数据类

    表示Task，里面有一个mActivities变量，这个变量ActivityRecord类型的ArrayList，而ArrayList就是按照Z轴位置的方式来存放ActivityRecord对象的。

  • ActivityStack

    里面有一个mTaskHistory变量，这个变量是一个TaskRecord类型的ArrayList，其中，TaskRecord又间接管理着ActivityRecord。

  • ActivityStackSupervisor

    主要管理ActivityStack，在android4.4版本以后，谷歌设计了两个ActivityStack，一个是Home stack，用来仿Launcher和SystemUI，id值为0，另一个是Application stack，用来仿其他应用程序，id值为非0。

ActivityStackSupervisor类有mStacks和mHomeStack这两个存放ActivityStack对象的ArrayList，其中mStacks在ActivityStackSupervisor的内部类ActivityDisplay中被定义。ActivityStack类的mTaskHistopry对象是一个存放TaskRecord对象的ArrayList。而TaskRecord类又有一个stack变量和mActivities变量，stack变量表示目前的ActivityStack，mActivities变量也是一个ArrayList，里面存放的就是ActivityRecord对象，对应到客户端，即存放的就是Activity，它们以Z轴的方式组织在一起，和WMS的窗口顺序一一对应。

AMS中重要对象的堆栈组织关系

Activity Manager

Activity Manager的组成分为以下几个部分：

  • 服务代理

    由ActivityManagerProxy实现，用于与Server端提供的系统服务进行进程间通信。

  • 服务中枢

    ActivityManagerNative继承自Binder并实现IActivityManager，它提供服务接口和Binder接口的相互转化功能，并在内部存储服务代理对象，并提供了getDefault()方法返回服务代理。

  • Client

    由ActivityManager封装一部分服务接口供Client调用。ActivityManager内部通过调用ActivityManagerNative的getDefault()方法，可以得到一个ActivityManagerProxy对象的引用，进而通过该代理对象调用远程服务的方法。

  • Server

    由ActivityManagerService实现，提供Server端的系统服务。

AMS的创建和初始化

ActivityManagerService（AMS）是android系统中一个非常重要的服务，它主要管理四大组件和进程内存的调度，它在SystemServer里的创建和启动，主要调用了一下几个方法：

  • 1
    2
    mActivityManagerService = mSystemServiceManager.startService(
                    ActivityManagerService.Lifecycle.class).getService();
  • 1
    mActivityManagerService.setSystemProcess();
  • 1
    mActivityManagerService.systemReady();

变量mSystemServiceManager是一个SystemServiceManager类型的对象，首先调用它的startService()方法创建AMS对象，接着调用这个AMS对象的setSystemProcess()方法来初始化AMS中的一些重要工作，最后调用systemReady()方法来判断AM是否启动和初始化成功。在android系统中，很多的核心服务都会提供systemReady()方法来判断它相应的服务是否启动和初始化成功，因为有些核心服务如果没有启动或者初始化失败，会严重影响系统的使用，如AMS，WMS等核心服务。而有些服务没有提供这个方法，比如MountService，因为MountService主要管理Sdcard这部分，如果这个服务没有启动或者初始化失败，只会影响sdcard，对系统的影响不是很大。

  • 首先来看一下startService()方法创建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
public <T extends SystemService> T startService(Class<T> serviceClass) {
    try {
        // 首先获得name为ActivityManagerService.Lifecycle
        final String name = serviceClass.getName();
        Slog.i(TAG, "Starting " + name);
        Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "StartService " + name);
        if (!SystemService.class.isAssignableFrom(serviceClass)) {
            throw new RuntimeException("Failed to create " + name
                    + ": service must extend " + SystemService.class.getName());
        }
        final T service;
        try {
            Constructor<T> constructor = serviceClass.getConstructor(Context.class);
            // 通过构造方法的反射创建了一个实例，这里是Lifecycle对象
            service = constructor.newInstance(mContext);
        } catch (InstantiationException ex) {
            throw new RuntimeException("Failed to create service " + name
                    + ": service could not be instantiated", ex);
        } catch (IllegalAccessException ex) {
            throw new RuntimeException("Failed to create service " + name
                    + ": service must have a public constructor with a Context argument", ex);
        } catch (NoSuchMethodException ex) {
            throw new RuntimeException("Failed to create service " + name
                    + ": service must have a public constructor with a Context argument", ex);
        } catch (InvocationTargetException ex) {
            throw new RuntimeException("Failed to create service " + name
                    + ": service constructor threw an exception", ex);
        }
        mServices.add(service);
        try {
            service.onStart();
        } catch (RuntimeException ex) {
            throw new RuntimeException("Failed to start service " + name
                    + ": onStart threw an exception", ex);
        }
        return service;
    } finally {
        Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
    }
}

SystemServiceManager类的startService()方法创建了一个Lifecycle实例，然后返回，而在SystemServer类里通过这个返回的实例调用getService()方法就获得AMS对象。Lifecycle是AMS的内部类，在创建这个实例的时候，会调用它的构造方法。（由于AMS并没有继承SystemService，因此不能通过SystemServiceManager的startService直接启动它 ）

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的构造方法创建了一个AMS实例对象，而它的getService()方法会返回构造方法里创建的这个AMS实例对象。

先来看看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
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
public ActivityManagerService(Context systemContext) {
    // AMS的运行上下文与SystemServer一致
    mContext = systemContext;
    mFactoryTest = FactoryTest.getMode();
    // 取出的是ActivityThread的静态变量sCurrentActivityThread，这意味着mSystemThread与                      SystemServer中的ActivityThread一致
    mSystemThread = ActivityThread.currentActivityThread();
    Slog.i(TAG, "Memory class: " + ActivityManager.staticGetMemoryClass());
    mHandlerThread = new ServiceThread(TAG,
            android.os.Process.THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
    mHandlerThread.start();
    //处理AMS中消息的主力
    mHandler = new MainHandler(mHandlerThread.getLooper());
    //UiHandler对应于Android中的UiThread
    mUiHandler = new UiHandler();
    if (sKillHandler == null) {
        sKillThread = new ServiceThread(TAG + ":kill",
                android.os.Process.THREAD_PRIORITY_BACKGROUND, true /* allowIo */);
        sKillThread.start();
        //用于接收消息，杀死进程
        sKillHandler = new KillHandler(sKillThread.getLooper());
    }
    //创建两个BroadcastQueue，前台的超时时间为10s，后台的超时时间为60s
    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;
    //创建变量，用于存储信息
    mServices = new ActiveServices(this);
    mProviderMap = new ProviderMap(this);
    mAppErrors = new AppErrors(mContext, this);
    File dataDir = Environment.getDataDirectory();
    File systemDir = new File(dataDir, "system");
    systemDir.mkdirs();
    //进行BatteryStatsService的初始化
    mBatteryStatsService = new BatteryStatsService(systemDir, mHandler);
    mBatteryStatsService.getActiveStatistics().readLocked();
    mBatteryStatsService.scheduleWriteToDisk();
    mOnBattery = DEBUG_POWER ? true
            : mBatteryStatsService.getActiveStatistics().getIsOnBattery();
    mBatteryStatsService.getActiveStatistics().setCallback(this);
    //创建ProcessStatsService，用于记录进程运行时的统计信息，例如内存使用情况，写入/proc/stat文件
    mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));
    //启动Android的权限检查服务，并注册对应的回调接口
    mAppOpsService = new AppOpsService(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);
                        }
                    }
                }
            });
    //用于定义ContentProvider访问指定Uri对应数据的权限，aosp中似乎没有这文件
    mGrantFile = new AtomicFile(new File(systemDir, "urigrants.xml"));
    //创建多用户管理器
    mUserController = new UserController(this);
    //获取OpenGL版本
    GL_ES_VERSION = SystemProperties.getInt("ro.opengles.version",
        ConfigurationInfo.GL_ES_VERSION_UNDEFINED);
    mTrackingAssociations = "1".equals(SystemProperties.get("debug.track-associations"));
    //资源配置信息置为默认值
    mConfiguration.setToDefaults();
    mConfiguration.setLocales(LocaleList.getDefault());
    mConfigurationSeq = mConfiguration.seq = 1;
    //用于记录进程的CPU使用情况
    mProcessCpuTracker.init();
    //解析/data/system/packages-compat.xml文件，该文件用于存储那些需要考虑屏幕尺寸的APK的一些信息，当           APK所运行的设备不满足要求时，AMS会根据xml设置的参数以采用屏幕兼容的方式运行该APK
    mCompatModePackages = new CompatModePackages(this, systemDir, mHandler);
    //用于根据规则过滤一些Intent
    mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);
    //以下的类，用于管理和监控AMS维护的Activity Task信息，ActivityStackSupervisor是AMS中用来管理               Activity启动和调度的核心类 
    mStackSupervisor = new ActivityStackSupervisor(this);
    mActivityStarter = new ActivityStarter(this, mStackSupervisor);
    mRecentTasks = new RecentTasks(this, mStackSupervisor);
    //创建线程用于统计进程的CPU使用情况
    mProcessCpuThread = new Thread("CpuTracker") {
        @Override
        public void run() {
            while (true) {
                try {
                    try {
                        //计算更新信息的等待间隔，同时利用wait等待计算出的间隔时间
                        synchronized(this) {
                            final long now = SystemClock.uptimeMillis();
                            long nextCpuDelay = (mLastCpuTime.get()+MONITOR_CPU_MAX_TIME)-now;
                            long nextWriteDelay = (mLastWriteTime+BATTERY_STATS_TIME)-now;
                            if (nextWriteDelay < nextCpuDelay) {
                                nextCpuDelay = nextWriteDelay;
                            }
                            if (nextCpuDelay > 0) {
                                mProcessCpuMutexFree.set(true);
                                this.wait(nextCpuDelay);
                            }
                        }
                    } catch (InterruptedException e) {
                    }
                    //更新CPU运行统计信息
                    updateCpuStatsNow();
                } catch (Exception e) {
                    Slog.e(TAG, "Unexpected exception collecting process stats", e);
                }
            }
        }
    };
    //加入Watchdog的监控
    Watchdog.getInstance().addMonitor(this);
    Watchdog.getInstance().addThread(mHandler);
}

AMS的构造函数还是相对比较简单的，主要工作就是初始化一些变量。 接下来看看AMS的start()函数。

1
2
3
4
5
6
7
8
9
10
11
private void start() {
        //完成统计前的复位工作
        Process.removeAllProcessGroups();
        //开始监控进程的CPU使用情况
        mProcessCpuThread.start();
        //注册服务
        mBatteryStatsService.publish(mContext);
        mAppOpsService.publish(mContext);
        Slog.d("AppOps", "AppOpsService published");
        LocalServices.addService(ActivityManagerInternal.class, new LocalService());
    }

AMS的start函数比较简单，主要是：

​ ①启动CPU监控线程。该线程将会开始统计不同进程使用CPU的情况。

​ ②发布一些服务，如BatteryStatsService、AppOpsService(权限管理相关)和本地实现的继承ActivityManagerInternal的服务。

  • 回到前面，接下来调用ActivityManagerService的setSystemProcess()方法。这个方法除了注册一些服务外，还将framework-res.apk的信息加入到SystemServer对应的LoadedApk中，同时构建SystemServer进程对应的ProcessRecord， 以将SystemServer纳入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
public void setSystemProcess() {
    try {
        // 添加AMS到ServiceManager中
        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) {
            //用于输出进程的CPU使用情况
            ServiceManager.addService("cpuinfo", new CpuBinder(this));
        }
        //注册权限管理服务
        ServiceManager.addService("permission", new PermissionController(this));
        //注册获取进程信息的服务
        ServiceManager.addService("processinfo", new ProcessInfoService(this));
        //向PKMS查询package名为“android”的应用的ApplicationInfo
        ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
                "android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
        // 调用installSystemApplicationInfo
        mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());
        // 以下与AMS的进程管理有关
        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);
            // 调整OOM_Adj值
            updateOomAdjLocked();
        }
    } catch (PackageManager.NameNotFoundException e) {
        throw new RuntimeException(
                "Unable to find android system package", e);
    }
}

从上面的代码可以看出，AMS的setSystemProcess主要有四个主要的功能：
​ ①通过Binder通信注册一些服务
​ ②获取package名为“android”的应用的ApplicationInfo
​ ③调用ActivityThread的installSystemApplicationInfo，将ApplicationInfo保存到SystemServer对应的ActivityThread中
​ ④AMS进程管理相关的操作

  • 最后，继续调用ActivityManagerService的systemReady()方法。
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
public void systemReady(final Runnable goingCallback) {
    synchronized(this) {
        if (mSystemReady) {
            if (goingCallback != null) {
                goingCallback.run();
            }
            return;
        }
        mLocalDeviceIdleController
                = LocalServices.getService(DeviceIdleController.LocalService.class);
        mUserController.onSystemReady();
        mRecentTasks.onSystemReadyLocked();
        mAppOpsService.systemReady();
        mSystemReady = true;
    }
    // 从mPidsSelfLocked中找到那些优先于AMS启动的进程，即manifest里声明persistent为true的那些进程
    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);
            }
        }
    }
    // 找到这些进程之后，通过removeProcessLocked()方法把它关闭
    synchronized(this) {
        if (procsToKill != null) {
            for (int i=procsToKill.size()-1; i>=0; i--) {
                ProcessRecord proc = procsToKill.get(i);
                Slog.i(TAG, "Removing system update proc: " + proc);
                removeProcessLocked(proc, true, false, "system update done");
            }
        }
        mProcessesReady = true;
    }
    Slog.i(TAG, "System now ready");
    EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_AMS_READY,
        SystemClock.uptimeMillis());
    synchronized(this) {
        if (mFactoryTest == FactoryTest.FACTORY_TEST_LOW_LEVEL) {
            ResolveInfo ri = mContext.getPackageManager()
                    .resolveActivity(new Intent(Intent.ACTION_FACTORY_TEST),
                            STOCK_PM_FLAGS);
            CharSequence errorMsg = null;
            if (ri != null) {
                ActivityInfo ai = ri.activityInfo;
                ApplicationInfo app = ai.applicationInfo;
                if ((app.flags&ApplicationInfo.FLAG_SYSTEM) != 0) {
                    mTopAction = Intent.ACTION_FACTORY_TEST;
                    mTopData = null;
                    mTopComponent = new ComponentName(app.packageName,
                            ai.name);
                } else {
                    errorMsg = mContext.getResources().getText(
                            com.android.internal.R.string.factorytest_not_system);
                }
            } else {
                errorMsg = mContext.getResources().getText(
                        com.android.internal.R.string.factorytest_no_action);
            }
            if (errorMsg != null) {
                mTopAction = null;
                mTopData = null;
                mTopComponent = null;
                Message msg = Message.obtain();
                msg.what = SHOW_FACTORY_ERROR_UI_MSG;
                msg.getData().putCharSequence("msg", errorMsg);
                mUiHandler.sendMessage(msg);
            }
        }
    }
    // 查询settings数据库，因为AMS会用到一些settings数据库里的数据
    retrieveSettings();
    final int currentUserId;
    synchronized (this) {
        currentUserId = mUserController.getCurrentUserIdLocked();
        readGrantedUriPermissionsLocked();
    }
    if (goingCallback != null) goingCallback.run();
    mBatteryStatsService.noteEvent(BatteryStats.HistoryItem.EVENT_USER_RUNNING_START,
            Integer.toString(currentUserId), currentUserId);
    mBatteryStatsService.noteEvent(BatteryStats.HistoryItem.EVENT_USER_FOREGROUND_START,
            Integer.toString(currentUserId), currentUserId);
    //调用所有系统服务的onStartUser接口
    mSystemServiceManager.startUser(currentUserId);
    synchronized (this) {
        //启动persistent为1的application所在的进程
        startPersistentApps(PackageManager.MATCH_DIRECT_BOOT_AWARE);
        mBooting = true;
        if (UserManager.isSplitSystemUser()) {
            ComponentName cName = new ComponentName(mContext, SystemUserHomeActivity.class);
            try {
                AppGlobals.getPackageManager().setComponentEnabledSetting(cName,
                        PackageManager.COMPONENT_ENABLED_STATE_ENABLED, 0,
                        UserHandle.USER_SYSTEM);
            } catch (RemoteException e) {
                throw e.rethrowAsRuntimeException();
            }
        }
        // 启动Launcher
        startHomeActivityLocked(currentUserId, "systemReady");
        try {
            //发送消息，触发处理Uid错误的Application
            if (AppGlobals.getPackageManager().hasSystemUidErrors()) {
                Slog.e(TAG, "UIDs on the system are inconsistent, you need to wipe your"
                        + " data partition or your device will be unstable.");
                mUiHandler.obtainMessage(SHOW_UID_ERROR_UI_MSG).sendToTarget();
            }
        } catch (RemoteException e) {
        }
        if (!Build.isBuildConsistent()) {
            Slog.e(TAG, "Build fingerprint is not consistent, warning user");
            mUiHandler.obtainMessage(SHOW_FINGERPRINT_ERROR_UI_MSG).sendToTarget();
        }
        long ident = Binder.clearCallingIdentity();
        try {
            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, Process.SYSTEM_UID,
                    currentUserId);
            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, Process.SYSTEM_UID, UserHandle.USER_ALL);
        } catch (Throwable t) {
            Slog.wtf(TAG, "Failed sending first user broadcasts", t);
        } finally {
            Binder.restoreCallingIdentity(ident);
        }
        mStackSupervisor.resumeFocusedStackTopActivityLocked();
        mUserController.sendUserSwitchBroadcastsLocked(-1, currentUserId);
    }
}

至此，ActivityManagerService的创建和它的核心方法的调用分析完毕。

AMS的作用

  • 各应用与服务之间的通信桥梁，由于Android屏蔽了进程概念，无论是应用内部的Activity或Servcie，还是另一应用的Activity或Service，启动都要经过AMS。按道理，我在应用内部Start一个Activity，直接new出来就行了，但在Android里，不能这样做，必须绕个弯，通过AMS，再由ams进入应用本身来启动。这样一来，所有应用进程里的所有Activity和Service，都保存在AMS里，AMS成了一个真正大管家。
  • 应用调用AMS，采用AMS提供的IActivityManager远程Binder接口。而AMS反调应用，则是应用提供的IApplicationThread远程Binder接口。当服务绑定之后，AMS反调应用提供的IServcieConnection远程Binder接口，来通知应用服务已经连接。

总结

AMS启动过程

回头看看整个过程，还是能比较清晰地将AMS的启动过程分为四步，如上图所示：

  • 创建出SystemServer进程的Android运行环境

    在这一部分，SystemServer进程主要创建出对应的ActivityThread和ContextImpl，构成Android运行环境。 AMS的后续工作依赖于SystemServer在此创建出的运行环境。

  • 完成AMS的初始化和启动

    在这一部分，单纯地调用AMS的构造函数和start函数，完成AMS的一些初始化工作。

  • 将SystemServer进程纳入到AMS的管理体系中

    AMS作为Java世界的进程管理和调度中心，要对所有Java进程一视同仁，因此SystemServer进程也必须被AMS管理。 在这个过程中，AMS加载了SystemServer中framework-res.apk的信息，并启动和注册了SettingsProvider.apk。

  • 开始执行AMS启动完毕后才能进行的工作

    系统中的一些服务和进程，必须等待AMS完成启动后，才能展开后续工作。 在这一部分，AMS通过调用systemReady函数，通知系统中的其它服务和进程，可以进行对应工作了。 在这个过程中，值得我们关注的是：Home Activity被启动了。当该Activity被加载完成后，最终会触发ACTION_BOOT_COMPLETED广播。