Android 系统源码分析——AMS分析

发表于 | 分类于

https://rainmonth.github.io/posts/A191018.html

在这里非常感谢Gityuan的博客，让人受益匪浅。

摘要

AMS，即ActivityManagerService，是Android系统的核心服务，负责四大组件的启动、切换、调度以及应用进程的调度和管理，其API并未对我们直接开放，在开放的ActivityManager中主要通过ActivityManagerNative来使用AMS提供的一些API，本文主要介绍AMS的启动过程。

[TOC]

AMS的启动过程

startBootstrapServices()

该方法在SystemServer.java(包名com.android.server，还有一个android/os/SystemServer.java)中定义，由于Zygote是Java进程的鼻祖，可以推测system_server进程也是由Zygote孵化而来。startBootstrapServices中AMS有关的内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
private void startBootstrapServices() {
        // 和app安装相关的代码，暂不详述
        Installer installer = mSystemServiceManager.startService(Installer.class);

        // 启动AMS 服务
        mActivityManagerService = mSystemServiceManager.startService(
                ActivityManagerService.Lifecycle.class).getService();
              // 设置服务管理器
        mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
              // 设置app安装器
        mActivityManagerService.setInstaller(installer);

              // 电源管理服务（该服务需要再点启动，因为很多其他服务依赖于它）
        mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);

        // 初始化电源管理
        mActivityManagerService.initPowerManagement();
                ...
        // 设置并开启记录一些系统进程的信息，如meminfo、gfxinfo、cpuinfo，是不是很常见？
        mActivityManagerService.setSystemProcess();
                ...
    }

启动AMS服务

上述方法执行到mActivityManagerService = mSystemServiceManager.startService( ActivityManagerService.Lifecycle.class).getService();，变启动了AMS服务。

AMS的构造方法

AMS的构造方法如下，该方法在主线程中调用，但方法内部涉及到Handler与其他线程的绑定，所以处理的时候需要额外关注使用的是那个Thread的Looper

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
public ActivityManagerService(Context systemContext) {
  mContext = systemContext;
  mFactoryTest = FactoryTest.getMode();
  mSystemThread = ActivityThread.currentActivityThread();

  Slog.i(TAG, "Memory class: " + ActivityManager.staticGetMemoryClass());
    // 创建名为“ActivityManager”的线程
  mHandlerThread = new ServiceThread(TAG,
                                     android.os.Process.THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
  mHandlerThread.start();

  mHandler = new MainHandler(mHandlerThread.getLooper());
  // 创建名为“android.ui”的线程
  mUiHandler = new UiHandler();
  // 广播相关
    // 前台广播接收器，超时时间为10s，超过10s会导致ANR
  mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
                                         "foreground", BROADCAST_FG_TIMEOUT, false);
  // 后台广播接收器，超时时间为60s，超过60s会导致ANR
  mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
                                         "background", BROADCAST_BG_TIMEOUT, true);
  mBroadcastQueues[0] = mFgBroadcastQueue;
  mBroadcastQueues[1] = mBgBroadcastQueue;

  // Service相关
  mServices = new ActiveServices(this);
  // Provider相关
  mProviderMap = new ProviderMap(this);

  // 创建/data/system目录
  File dataDir = Environment.getDataDirectory();
  File systemDir = new File(dataDir, "system");
  systemDir.mkdirs();
  // 创建BatterStatsService
  mBatteryStatsService = new BatteryStatsService(systemDir, mHandler);
  mBatteryStatsService.getActiveStatistics().readLocked();
  mBatteryStatsService.scheduleWriteToDisk();
  mOnBattery = DEBUG_POWER ? true
    : mBatteryStatsService.getActiveStatistics().getIsOnBattery();
  mBatteryStatsService.getActiveStatistics().setCallback(this);
    // 进程统计服务
  mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));
  mAppOpsService = new AppOpsService(new File(systemDir, "appops.xml"), mHandler);
  mGrantFile = new AtomicFile(new File(systemDir, "urigrants.xml"));

  // User 0 is the first and only user that runs at boot.
  mStartedUsers.put(UserHandle.USER_OWNER, new UserState(UserHandle.OWNER, true));
  mUserLru.add(UserHandle.USER_OWNER);
  updateStartedUserArrayLocked();

  GL_ES_VERSION = SystemProperties.getInt("ro.opengles.version",
                                          ConfigurationInfo.GL_ES_VERSION_UNDEFINED);

  mTrackingAssociations = "1".equals(SystemProperties.get("debug.track-associations"));

  mConfiguration.setToDefaults();
  mConfiguration.setLocale(Locale.getDefault());

  mConfigurationSeq = mConfiguration.seq = 1;
  // 初始化进程CPU追踪器
  mProcessCpuTracker.init();

  mCompatModePackages = new CompatModePackages(this, systemDir, mHandler);
  mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);
  mRecentTasks = new RecentTasks(this);
  // 创建ActivityStackSupervisor对象
  mStackSupervisor = new ActivityStackSupervisor(this, mRecentTasks);
  mTaskPersister = new TaskPersister(systemDir, mStackSupervisor, mRecentTasks);

  mProcessCpuThread = new Thread("CpuTracker") {
    @Override
    public void run() {
      while (true) {
        try {
          try {
            synchronized(this) {
              final long now = SystemClock.uptimeMillis();
              long nextCpuDelay = (mLastCpuTime.get()+MONITOR_CPU_MAX_TIME)-now;
              long nextWriteDelay = (mLastWriteTime+BATTERY_STATS_TIME)-now;
              //Slog.i(TAG, "Cpu delay=" + nextCpuDelay
              //        + ", write delay=" + nextWriteDelay);
              if (nextWriteDelay < nextCpuDelay) {
                nextCpuDelay = nextWriteDelay;
              }
              if (nextCpuDelay > 0) {
                mProcessCpuMutexFree.set(true);
                this.wait(nextCpuDelay);
              }
            }
          } catch (InterruptedException e) {
          }
          updateCpuStatsNow();
        } catch (Exception e) {
          Slog.e(TAG, "Unexpected exception collecting process stats", e);
        }
      }
    }
  };

  Watchdog.getInstance().addMonitor(this);
  Watchdog.getInstance().addThread(mHandler);
}

在AMS的构造方法里，开启了三个线程，分别是：

  • mHandler->MainHandler，其对应的是名为“ActivityManager”的前台ServiceThread（拥有很高的优先级）；
  • mUiHandler->UiHandler，其对应的是名为“android.ui”的UiThread(继承自ServiceThread）；
  • mProcessCpuThread，直接通过new Thread构造，名称为“CpuTracer”；

AMS的start方法

该方法在AMS内部类Lifecycle对象的start方法中被调用

1
2
3
4
5
6
7
8
9
10
11
private void start() {
      // 移除所有进程组
    Process.removeAllProcessGroups();
      // 开启CpuTracer线程
    mProcessCpuThread.start();
        // 启动电池统计服务
    mBatteryStatsService.publish(mContext);
    mAppOpsService.publish(mContext);
    Slog.d("AppOps", "AppOpsService published");
    LocalServices.addService(ActivityManagerInternal.class, new LocalService());
}

setSystemProcess方法

该方法在SystemServer的startBootstrapServices()中被调用，主要作用是：

  1. 注册各种服务；
  2. 注册package为android 的包信息，最终是通过LoadedApk的installSystemApplicationInfo完成的
  3. 采用Lru算法更新app进程信息
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
public void setSystemProcess() {
    try {
          // 对应1
        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));

          // 对应2
        ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
                "android", STOCK_PM_FLAGS);
        mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());

          // 对应3
        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();
        }
    } catch (PackageManager.NameNotFoundException e) {
        throw new RuntimeException(
                "Unable to find android system package", e);
    }
}

这里面的几个Binder是不是很熟悉，对的，就是我们adb shell dumpsys 经常用到的拉取信息分析性能用的。

到这statBootstrapServices()中关于AMS的内容就完了，接下来看看startOtherServices()中关于AMS的部分。

startOtherServices()

先列出该方法中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
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
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
private void startOtherServices() {

    try {
        ...
        // 安装系统Provider
        mActivityManagerService.installSystemProviders();
                ...
        // 创建WMS对象并设置给AMS，这样AMS就持有WMS的实例了
        wm = WindowManagerService.main(context, inputManager,
                mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL,
                !mFirstBoot, mOnlyCore);
        ServiceManager.addService(Context.WINDOW_SERVICE, wm);
        ServiceManager.addService(Context.INPUT_SERVICE, inputManager);

        mActivityManagerService.setWindowManager(wm);
    } catch (RuntimeException e) {
        Slog.e("System", "******************************************");
        Slog.e("System", "************ Failure starting core service", e);
    }
        ...
    try {
        ActivityManagerNative.getDefault().showBootMessage(
                context.getResources().getText(
                        com.android.internal.R.string.android_upgrading_starting_apps),
                false);
    } catch (RemoteException e) {
    }
        ...
    // 安全模式处理代码
    final boolean safeMode = wm.detectSafeMode();
    if (safeMode) {
        mActivityManagerService.enterSafeMode();
        // Disable the JIT for the system_server process
        VMRuntime.getRuntime().disableJitCompilation();
    } else {
        // Enable the JIT for the system_server process
        VMRuntime.getRuntime().startJitCompilation();
    }

    // 进入到SystemServer的下一阶段phase480和phase500
    mSystemServiceManager.startBootPhase(SystemService.PHASE_LOCK_SETTINGS_READY);
    mSystemServiceManager.startBootPhase(SystemService.PHASE_SYSTEM_SERVICES_READY);

    try {
          // 调用wms的systemReady()方法
        wm.systemReady();
    } catch (Throwable e) {
        reportWtf("making Window Manager Service ready", e);
    }

    if (safeMode) {
          // 显示安全模式相关的View
        mActivityManagerService.showSafeModeOverlay();
    }

      // 通知ActivityManager现在可以运行第三方代码了，当第三方代码真的可以运行时，会通过回调方法告诉SystemServer去结束初始化的工作
    mActivityManagerService.systemReady(new Runnable() {
        @Override
        public void run() {
            Slog.i(TAG, "Making services ready");
              // 进入phase550阶段
            mSystemServiceManager.startBootPhase(
                    SystemService.PHASE_ACTIVITY_MANAGER_READY);

            try {
                  // 开始监听native crash
                mActivityManagerService.startObservingNativeCrashes();
            } catch (Throwable e) {
                reportWtf("observing native crashes", e);
            }

            Slog.i(TAG, "WebViewFactory preparation");
            WebViewFactory.prepareWebViewInSystemServer();

            try {
                startSystemUi(context);
            } catch (Throwable e) {
                reportWtf("starting System UI", e);
            }
            try {
                if (networkScoreF != null) networkScoreF.systemReady();
            } catch (Throwable e) {
                reportWtf("making Network Score Service ready", e);
            }
            try {
                if (networkManagementF != null) networkManagementF.systemReady();
            } catch (Throwable e) {
                reportWtf("making Network Managment Service ready", e);
            }
            try {
                if (networkStatsF != null) networkStatsF.systemReady();
            } catch (Throwable e) {
                reportWtf("making Network Stats Service ready", e);
            }
            try {
                if (networkPolicyF != null) networkPolicyF.systemReady();
            } catch (Throwable e) {
                reportWtf("making Network Policy Service ready", e);
            }
            try {
                if (connectivityF != null) connectivityF.systemReady();
            } catch (Throwable e) {
                reportWtf("making Connectivity Service ready", e);
            }
            try {
                if (audioServiceF != null) audioServiceF.systemReady();
            } catch (Throwable e) {
                reportWtf("Notifying AudioService running", e);
            }
            Watchdog.getInstance().start();

            // It is now okay to let the various system services start their
            // third party code...
            mSystemServiceManager.startBootPhase(
                    SystemService.PHASE_THIRD_PARTY_APPS_CAN_START);

            try {
                if (wallpaperF != null) wallpaperF.systemRunning();
            } catch (Throwable e) {
                reportWtf("Notifying WallpaperService running", e);
            }
            try {
                if (immF != null) immF.systemRunning(statusBarF);
            } catch (Throwable e) {
                reportWtf("Notifying InputMethodService running", e);
            }
            try {
                if (locationF != null) locationF.systemRunning();
            } catch (Throwable e) {
                reportWtf("Notifying Location Service running", e);
            }
            try {
                if (countryDetectorF != null) countryDetectorF.systemRunning();
            } catch (Throwable e) {
                reportWtf("Notifying CountryDetectorService running", e);
            }
            try {
                if (networkTimeUpdaterF != null) networkTimeUpdaterF.systemRunning();
            } catch (Throwable e) {
                reportWtf("Notifying NetworkTimeService running", e);
            }
            try {
                if (commonTimeMgmtServiceF != null) {
                    commonTimeMgmtServiceF.systemRunning();
                }
            } catch (Throwable e) {
                reportWtf("Notifying CommonTimeManagementService running", e);
            }
            try {
                if (textServiceManagerServiceF != null)
                    textServiceManagerServiceF.systemRunning();
            } catch (Throwable e) {
                reportWtf("Notifying TextServicesManagerService running", e);
            }
            try {
                if (atlasF != null) atlasF.systemRunning();
            } catch (Throwable e) {
                reportWtf("Notifying AssetAtlasService running", e);
            }
            try {
                // TODO(BT) Pass parameter to input manager
                if (inputManagerF != null) inputManagerF.systemRunning();
            } catch (Throwable e) {
                reportWtf("Notifying InputManagerService running", e);
            }
            try {
                if (telephonyRegistryF != null) telephonyRegistryF.systemRunning();
            } catch (Throwable e) {
                reportWtf("Notifying TelephonyRegistry running", e);
            }
            try {
                if (mediaRouterF != null) mediaRouterF.systemRunning();
            } catch (Throwable e) {
                reportWtf("Notifying MediaRouterService running", e);
            }

            try {
                if (mmsServiceF != null) mmsServiceF.systemRunning();
            } catch (Throwable e) {
                reportWtf("Notifying MmsService running", e);
            }
        }
    });
}

systemReady()

重点说说AMS的systemReady方法，在SystemServer中调用AMS的systemReady方法时，传递了一个Runnable对象。

根据goingCallback的执行情况，该方法可以分三个阶段：

  • before goingCallback run；
  • goingCallback running，goingCallback运行阶段；
  • after goingCallback run；
before goingCallback

该阶段主要功能：

  1. 向ACTION_PRE_BOOT_COMPLETED的接收者发送广播，由deliverPreBootCompleted方法完成；
  2. 杀掉processToKill中的进程，且不允许重启
  3. 系统和process都达到ready状态
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
synchronized(this) {
      // 首次进入mSystemReady为false，不进入该分支；
    if (mSystemReady) {
        if (goingCallback != null) {
            goingCallback.run();
        }
        return;
    }

    mLocalDeviceIdleController
            = LocalServices.getService(DeviceIdleController.LocalService.class);

    updateCurrentProfileIdsLocked();
        // 最近任务相关处理（清空并恢复）
    mRecentTasks.clear();
    mRecentTasks.addAll(mTaskPersister.restoreTasksLocked());
    mRecentTasks.cleanupLocked(UserHandle.USER_ALL);
    mTaskPersister.startPersisting();

    // 检查是否需要更新
    if (!mDidUpdate) {
        if (mWaitingUpdate) {
            return;
        }
        final ArrayList<ComponentName> doneReceivers = new ArrayList<ComponentName>();
        mWaitingUpdate = deliverPreBootCompleted(new Runnable() {
            public void run() {
                synchronized (ActivityManagerService.this) {
                    mDidUpdate = true;
                }
                showBootMessage(mContext.getText(
                        R.string.android_upgrading_complete),
                        false);
                writeLastDonePreBootReceivers(doneReceivers);
                systemReady(goingCallback);
            }
        }, doneReceivers, UserHandle.USER_OWNER);

        if (mWaitingUpdate) {
            return;
        }
        mDidUpdate = true;
    }

    mAppOpsService.systemReady();
    mSystemReady = 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);
        }
    }
}

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

    // Now that we have cleaned up any update processes, we
    // are ready to start launching real processes and know that
    // we won't trample on them any more.
    mProcessesReady = true;
}

Slog.i(TAG, "System now ready");
EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_AMS_READY,
    SystemClock.uptimeMillis());
deliverPreBootCompleted
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
private boolean deliverPreBootCompleted(final Runnable onFinishCallback,
                                        ArrayList<ComponentName> doneReceivers, int userId) {
  Intent intent = new Intent(Intent.ACTION_PRE_BOOT_COMPLETED);
  List<ResolveInfo> ris = null;
  try {
    ris = AppGlobals.getPackageManager().queryIntentReceivers(
      intent, null, 0, userId);
  } catch (RemoteException e) {
  }
  if (ris == null) {
    return false;
  }
  for (int i=ris.size()-1; i>=0; i--) {
    if ((ris.get(i).activityInfo.applicationInfo.flags
         &ApplicationInfo.FLAG_SYSTEM) == 0) {
      ris.remove(i);
    }
  }
  intent.addFlags(Intent.FLAG_RECEIVER_BOOT_UPGRADE);

  // For User 0, load the version number. When delivering to a new user, deliver
  // to all receivers.
  if (userId == UserHandle.USER_OWNER) {
    ArrayList<ComponentName> lastDoneReceivers = readLastDonePreBootReceivers();
    for (int i=0; i<ris.size(); i++) {
      ActivityInfo ai = ris.get(i).activityInfo;
      ComponentName comp = new ComponentName(ai.packageName, ai.name);
      if (lastDoneReceivers.contains(comp)) {
        // 已经处理过的，就不在处理了
        ris.remove(i);
        i--;
        // ...however, do keep it as one that has been done, so we don't
        // forget about it when rewriting the file of last done receivers.
        doneReceivers.add(comp);
      }
    }
  }

  if (ris.size() <= 0) {
    return false;
  }

  // If primary user, send broadcast to all available users, else just to userId
  final int[] users = userId == UserHandle.USER_OWNER ? getUsersLocked()
    : new int[] { userId };
  if (users.length <= 0) {
    return false;
  }

  PreBootContinuation cont = new PreBootContinuation(intent, onFinishCallback, doneReceivers,
ris, users);
  cont.go();
  return true;
}
PreBootContinuation

AMS的内部类PreBootContinuation，主要通过go方法完成广播的发送工作。

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
final class PreBootContinuation extends IIntentReceiver.Stub {
  final Intent intent;
  final Runnable onFinishCallback;
  final ArrayList<ComponentName> doneReceivers;
  final List<ResolveInfo> ris;
  final int[] users;
  int lastRi = -1;
  int curRi = 0;
  int curUser = 0;

  PreBootContinuation(Intent _intent, Runnable _onFinishCallback,
                      ArrayList<ComponentName> _doneReceivers, List<ResolveInfo> _ris, int[] _users) {
    intent = _intent;
    onFinishCallback = _onFinishCallback;
    doneReceivers = _doneReceivers;
    ris = _ris;
    users = _users;
  }

  void go() {
    if (lastRi != curRi) {
      ActivityInfo ai = ris.get(curRi).activityInfo;
      ComponentName comp = new ComponentName(ai.packageName, ai.name);
      intent.setComponent(comp);
      doneReceivers.add(comp);
      lastRi = curRi;
      CharSequence label = ai.loadLabel(mContext.getPackageManager());
      showBootMessage(mContext.getString(R.string.android_preparing_apk, label), false);
    }
    Slog.i(TAG, "Pre-boot of " + intent.getComponent().toShortString()
           + " for user " + users[curUser]);
    EventLogTags.writeAmPreBoot(users[curUser], intent.getComponent().getPackageName());
    broadcastIntentLocked(null, null, intent, null, this,
                          0, null, null, null, AppOpsManager.OP_NONE,
                          null, true, false, MY_PID, Process.SYSTEM_UID, users[curUser]);
  }

  public void performReceive(Intent intent, int resultCode,
                             String data, Bundle extras, boolean ordered,
                             boolean sticky, int sendingUser) {
    curUser++;
    if (curUser >= users.length) {
      curUser = 0;
      curRi++;
      if (curRi >= ris.size()) {
        // All done sending broadcasts!
        if (onFinishCallback != null) {
          // The raw IIntentReceiver interface is called
          // with the AM lock held, so redispatch to
          // execute our code without the lock.
          mHandler.post(onFinishCallback);
        }
        return;
      }
    }
    go();
  }
}
goingCallback.run()

即执行systemReady传递过来的Runnable的run方法，该方法主要完成：

  • 进入SystemServer的phase550阶段；（ActivityManager ready阶段）
  • 启动WebView，启动systemUi；
  • 启动一些列服务，并调用他们的systemReady方法
  • 进入SystemServer的phase600阶段（第三方App可以启动了）
after goingCallback
  • 回调所有service的startuser方法；
  • 启动persistent进程（App）；
  • 启动Home Activity；
  • 发送USER_STARTED和USER_STARTING广播；
  • 恢复栈顶Activity
  • 发送用户切换广播
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
// 回调所有service的starUser方法（mSystemServiceManager在SystemServer的startBootstrapServices()方法中初始化
mSystemServiceManager.startUser(mCurrentUserId);
synchronized (this) {
  if (mFactoryTest != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
    try {
      List apps = AppGlobals.getPackageManager().
        getPersistentApplications(STOCK_PM_FLAGS);
      if (apps != null) {
        int N = apps.size();
        int i;
        for (i=0; i<N; i++) {
          ApplicationInfo info
            = (ApplicationInfo)apps.get(i);
          if (info != null && !info.packageName.equals("android")) {
                        // 启动persistent进程
            addAppLocked(info, false, null /* ABI override */);
          }
        }
      }
    } catch (RemoteException ex) {
      // pm is in same process, this will never happen.
    }
  }

  // 启动Home Activity。
  mBooting = true;
  startHomeActivityLocked(mCurrentUserId, "systemReady");

  try {
    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_MSG).sendToTarget();
    }
  } catch (RemoteException e) {
  }

  if (!Build.isBuildConsistent()) {
    Slog.e(TAG, "Build fingerprint is not consistent, warning user");
    mUiHandler.obtainMessage(SHOW_FINGERPRINT_ERROR_MSG).sendToTarget();
  }

  long ident = Binder.clearCallingIdentity();
  try {
        // 发送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, mCurrentUserId);
    broadcastIntentLocked(null, null, intent,
                          null, null, 0, null, null, null, AppOpsManager.OP_NONE,
                          null, false, false, MY_PID, Process.SYSTEM_UID, mCurrentUserId);
    // 发送USER_STARTING广播
    intent = new Intent(Intent.ACTION_USER_STARTING);
    intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
    intent.putExtra(Intent.EXTRA_USER_HANDLE, mCurrentUserId);
    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);
  }
  // 恢复栈顶Activity
  mStackSupervisor.resumeTopActivitiesLocked();
  // 发送用户切换广播
  sendUserSwitchBroadcastsLocked(-1, mCurrentUserId);
}

小结

大致讲过上面的步骤，AMS启动相关的工作就做完了，再来梳理一下：

  1. 在SystemServer的startBoostrapServices()方法中创建AMS对象，并启动服务，构造函数完成了相关线程的创建；
  2. 在SystemServer的startBoostrapServices()方法中调用AMS的setSystemProcess()方法，完成了AMS、meminfo等在SystemServer中的注册，我们adb shell dumpsys的一系列命令就是这里提供的；
  3. AMS对四大组件均有涉及，因为以下对象都在其构造方法里面创建
    1. BroadcastQueue，对应BroadcastReceiver；
    2. ActiveService，对应于Service；
    3. ProvideMap，对应于ContentProvider；
    4. ActivityStackSupervisor，对应于Activity；
  4. UIHandler完成了系统级弹窗的处理，如ANR、调试弹窗、用户错误弹窗等；
  5. MainHander完成设置更新、后台GC、Service超时、等系统级配置变化的处理；

参考文章